Introduction To Various Data Structures

A data structure represents storage format that is used to store and organize data. It is a way of arranging data in computer memory so that it can be accessed and updated efficiently. Data structures are grouped based on the type of operations required to perform. The two broad types of the data structure are:

Types of Data Structures

• Primitive data structures:  The primitive data structure is a fundamental building block of data structures. It is a predefined way of storing data of only one type. In other words, it can hold a single value in a specific memory location. Some examples of primitive data structures are: int, float, and char, and boolean (true or false).
• Non-primitive data structures or the derived data structures: The Non-Primitive data structure can be further categorized into Linear and Nonlinear data structures, which can be further classified based on how the data is stored. The types of trees in the data structure flow are as follows:
• Linear data structure: Data structure in which data elements are arranged sequentially or linearly, where each element is attached to its previous and next adjacent elements, is called a linear data structure. Examples of linear data structures are array, stack, queue, linked list, etc.
• Static data structure: Static data structure has a fixed memory size. It is easier to access the elements in a static data structure. An example of this data structure is an array.
• Dynamic data structure: In dynamic data structure, the size is not fixed. It can be randomly updated during the runtime which may be considered efficient concerning the memory (space) complexity of the code. Examples of this data structure are queue, stack, etc.
• Non-linear data structure: Data structures where data elements are not placed sequentially or linearly are called non-linear data structures. In a non-linear data structure, we can’t traverse all the elements in a single run only. Examples of non-linear data structures are trees and graphs.

Basics of popular Data Structures

• Arrays: One of the simplest data structures, an array is a collection of items that are stored sequentially. An array contains values or variables—known as “elements”—of the same data type and is of a fixed size, so you cannot change the size of an array. Each item in an array is indexed starting with 0. The best way to think about an array is like a weekly medication organizer. It includes small containers lined up in a sequence, and each container has elements inside. Arrays are commonly used as structures for building other, more complicated data structures. They are also used for sorting algorithms.

• Linked Lists: A linked list is a sequence of items arranged in a linear order all connected to each other. This means you must access data in order, so random access to data is not possible. Each element in a linked list is called a “node,” and each node contains a key and a pointer. The pointer directs you to the next node, called a “next.” The sequence starts with a “head,” which directs you to the first element within the list. The last element of this list is known as the “tail.” You can create a singly linked list, which lets you traverse each item in a forward direction from the head to the tail. Similarly, you can create a doubly-linked list, which can be traversed both forward and backward. And finally, you can create a circular linked list in which the next pointer of the tail points to the head and vice versa, forming a circle. Linked lists are used for symbol table management in switching between programs using Alt + Tab (On a PC).

• Stacks: A stack works almost exactly as it sounds. It’s like stacking elements within a tall container. Stacks are known as LIFO (Last In First Out) structures. This means the element placed last can be accessed first. You can “push” a new element onto the top of the stack, or you can “pop,” deleting the element inserted last which is at the top of the stack. Stacks are commonly used for parsing and evaluating mathematical expressions and to implement function calls in recursion programming.

• Queues: A queue functions similarly to a stack, but instead of being a LIFO structure, it is a FIFO (First In First Out) structure. The easiest way to think about a queue is to think of a line of people waiting to enter a building. The person at the beginning of the line will enter the building first, while the person at the end will enter last. You can enqueue an element in this structure, which means inserting the element to the end of the queue. You can also dequeue an element, which means deleting an element from the beginning of the queue. Queues are often used to manage threads in multithreading, and they are (not surprisingly) used to implement priority queuing systems.

• Hash Tables: A hash table structure associates each value with a key and then stores them. This makes it easy to look up values efficiently using a key. It’s an efficient way to insert and search for data regardless of its size, as it makes it easy to identify a specific object from a group of similar objects. For example, if you go to college, you may be assigned a unique student ID number. This ID number is a key that can be used to retrieve information about you and your student record. A hash table uses what’s known as a “hash function” to map a data set of any size to one of a fixed size—the hash table. The values that a hash function returns are known as “hash values.” Hash tables are commonly used to create database indexes, to create associative arrays and to create a “set.”

• Trees: A tree is a structure similar to a linked list because each item is linked. But in a tree items are linked in a hierarchal fashion, just like you might see in a visual representation of someone’s family tree. There are various types of trees, each suited to different applications. For example, a binary search tree (BST) stores data in sorted order with every node in the binary comprised of the following attributes:
• Key (the value saved in the node)
• Left (pointer to the left child node)
• Right (pointer to the right child node)
• P (pointer to the parent node)
• Binary search trees are used in many different types of search applications. Other types of trees are used in wireless networking and to create expression solvers.

• Graphs: A graph is an abstract, non-linear data structure that is made of a finite set of nodes that are connected by edges. The nodes may be referred to as “vertices” and contain values, whereas the edges are simply lines or arcs that connect two nodes in the graph. Graphs are often used to represent networks, such as circuit networks or even paths in a city. They're great for solving real-world problems, but they can also be used as representations of digital networks. For example, on Facebook, each user could be represented with a node (or vertex). Each vertex could then contain information about that user, and each edge could represent their connection with another user.