- Home
- Data Structures

Choose the Right One for Your Coding Challenges

The short answer to What is a Data Structure? Itâ€™s a way of organizing and storing data in a computer so that it can be accessed and modified efficiently. Different types of data structures are suited to different kinds of problems and programs. Know what is static/dynamic, linear/non-linear, commonly used for coding interviews, and advanced data structures. Here's a simple real-world example of how even a kid would apply a data structure.

Imagine that you have a bunch of toy cars, and you want to keep them in a box. You could just throw them all in the box, but that would make it hard to find the one you want. So instead, you could organize them in any order you want by color, size, or some other way that makes sense to you. That would be like using a data structure.

Think of it as a set of rules for how to organize and store data in a computer so that it can be used the . There are different types of data structures, just like there are different ways to organize your toy cars. Some data structures are good for storing and finding information quickly, while others are better for adding and removing things easily.

Data structures are used in lots of different computer programs to help them work efficiently and do their job correctly. Just like how you use a special way of organizing your toy cars to make it easier to play with them, computer programs use data structures to make it easier for them to work with and use the data they need.

Do you know what is a data structure when it is static or dynamic? The s**tatic data structure** has a fixed size, meaning the size cannot be changed after it is created. The **dynamic data structures** can have their size changed during runtime.
For example, the classic array is a static data structure because its size is fixed when it is created. If you need to add more elements to an array, you must create a brand new, larger array and copy the elements plus the additional ones.
On the other hand, a linked list is a dynamic data structure because its size can change during runtime. You can add or remove elements from a linked list without the need to create a new one.

Another key aspect of knowing what is a data structure is linear vs non-linear. The **linear data structure **has elements that are stored in a linear sequence, such as an array or a linked list. A non-linear data structure has elements stored in a hierarchical or network-like structure, such as a tree, graph, or hash table. Software engineering always involves making trade-offs. For instance, **non-linear data structures** usually offer better performance and more flexibility, because they allow for more complex relationships between the elements.

For example, an array is a linear data structure because the elements are stored in "adjacent connected blocks" of memory. A tree, on the other hand, is a non-linear data structure because the elements are arranged in a hierarchy, with each element spanning one or more child elements.

Most Commonly Used

**Array**

A collection of items stored at contiguous memory locations. The items can be of the same type or different types.

- Linear
- Static

**Linked List**

A linear data structure that consists of a sequence of nodes, where each node stores a reference to the next node in the sequence.

- Linear
- Dynamic

**Stack**

A last-in, first-out (LIFO) data structure that allows insertions and deletions to be made at only one end (the top of the stack).

- Linear
- Dynamic

**Queue**

A first-in, first-out (FIFO) data structure that allows insertions to be made at one end (the tail of the queue) and deletions to be made at the other end (the head of the queue).

- Linear
- Dynamic

**Tree**

A hierarchical data structure that consists of nodes organized into a tree-like structure. Each node has at most two children (a left and a right child) and a reference to its parent.

- Non-Linear
- Dynamic

**Graph**

A non-linear data structure that consists of a set of vertices (nodes) and a set of edges connecting the vertices. Graphs can be directed (where the edges have a direction) or undirected (where the edges have no direction).

- Non-Linear
- Dynamic

**Hash Table**

A data structure that stores keys and values in an array, using a hash function to map the keys to array indices. Hash tables allow for efficient insertion, deletion, and lookup of data.

- Non-Linear
- Dynamic

**Heap**

A complete binary tree in which the value of each node is greater than or equal to the values of its children (for a max heap) or less than or equal to the values of its children (for a min heap). Heaps are commonly used to implement priority queues.

- Non-Linear
- Dynamic

**Matrix**

A two-dimensional array of numbers, arranged in rows and columns. Matrices are commonly used to represent linear transformations in mathematics and computer graphics.

- Non-Linear
- Dynamic

**Trie (Prefix Tree)**

A tree-like data structure that is used to store an associative array where the keys are sequences (usually strings). Tries are efficient for searching and sorting large sets of strings.

- Non-Linear
- Dynamic

**Binary Tree**

A tree data structure in which each node has at most two children (a left and a right child). Binary trees can be used to implement various data structures, such as search trees and priority queues.

- Non-Linear
- Dynamic

**Binary Search Tree**

A binary tree data structure in which the value of each node is greater than all the values in its left subtree and less than all the values in its right subtree. Binary search trees can be used to efficiently search for, insert, and delete elements in a sorted list.

- Non-Linear
- Dynamic

(And Senior Coding Interviews)

**Set**

A collection of unique items, without any particular order. Sets can be implemented using various data structures, such as hash tables, trees, or arrays.

- Non-Linear
- Dynamic

**Map**

A collection of key-value pairs, where each key is unique and is used to retrieve the corresponding value. Maps can be implemented using various data structures, such as hash tables, trees, or arrays.

- Non-Linear
- Dynamic

**Deque: Double-Ended Queue**

A data structure that allows insertions and deletions to be made at both ends (the front and the back). Deques can be implemented using various data structures, such as arrays, linked lists, or circular buffers.

- Linear
- Dynamic

**B-Tree**

A tree data structure that is used to store sorted data in a way that allows for efficient insertion, deletion, and search operations. B-trees have a high branching factor, meaning that they can have a large number of children per node.

- Non-Linear
- Dynamic

**Red-Black Tree**

A self-balancing binary search tree data structure. Red-black trees maintain balance by coloring the nodes of the tree either red or black, and enforcing certain constraints on the coloring.

- Non-Linear
- Dynamic

**Splay Tree**

A self-balancing binary search tree data structure. Splay trees maintain balance by restructuring the tree after each access to a node.

- Non-Linear
- Dynamic

**Bloom Filter**

A space-efficient probabilistic data structure that is used to test membership in a set. Bloom filters allow for fast membership tests, but may return false positives (saying that an element is in the set when it is not).

- Non-Linear
- Dynamic

**Segment Tree**

A tree data structure that is used to perform range queries and updates on an array. Segment trees allow for O(log n) time complexity for both operations, where n is the size of the array.

- Non-Linear
- Dynamic

**Binary Indexed Tree Fenwick Tree**

A data structure that is used to perform efficient range queries and updates on an array. Binary indexed trees allow for O(log n) time complexity for both operations, where n is the size of the array.

- Non-Linear
- Dynamic

**Suffix Array**

A sorted array of all the suffixes of a given string. Suffix arrays are used to perform efficient searches and pattern matching on strings.

- Non-Linear
- Dynamic

**Suffix Tree**

A tree-like data structure that is used to perform efficient searches and pattern matching on strings. Suffix trees allow for O(m) time complexity for searches, where m is the length of the search pattern.

- Non-Linear
- Dynamic

**AVL Tree**

A self-balancing binary search tree data structure. AVL trees maintain balance by ensuring that the difference in the heights of the left and right subtrees is at most 1.

- Non-Linear
- Dynamic

**K-Dimensional Tree (KDTree)**

A tree that is used to store points in K-dimensional space. KDTrees allow for efficient searches for points within a given range or nearest neighbors.

- Non-Linear
- Dynamic