Data Structures

First PublishedFeb 14, 2026ByAtif Alam

These are the main data structures that show up in the algorithms we cover. Some have their own topic page; others are the input or the building block for techniques.

Data structures here include both the forms your input might take (array, graph, tree) and the structures we use while solving (stacks, heaps, hash maps, etc.).

For a list of typical input shapes only, see Typical input types on the overview.

Structures Used Across Algorithms

Array / list — Contiguous, indexable sequence. Used in: two pointers, sliding window, binary search, prefix sum, sorting.
Hash map / hash set — O(1) lookup/insert (amortized). Used in: sliding window (counts), subarray-sum problems, dynamic programming (memoization), duplicate checks.
Stack — LIFO. Used in: iterative DFS, backtracking, parsing.
Queue — FIFO. Used in: BFS, level-order traversal. In Python: deque from collections.
Deque — Double-ended queue. Used in: BFS, some sliding-window problems.
Graph — Vertices and edges; given as edge list, adjacency list (e.g. dict of neighbors), or adjacency matrix. Used in: BFS, DFS, Union Find, shortest paths.
Tree — Often represented like a graph (pointers or parent array) or in array form (e.g. heap). Used in: DFS, BFS, divide and conquer, heaps.

Structures With Their Own Topic Page

Heap — Priority queue; min or max at the root. Used for “kth largest,” top K, merge k lists.
Trie — Prefix tree for strings; each path spells a prefix. Used for autocomplete, word search, prefix matching.
Union Find — Disjoint set union; merge sets and ask “same set?” Used for connected components, Kruskal’s MST, dynamic connectivity.

ASCII Diagrams

Below are simple ASCII diagrams for how each structure is laid out or traversed.

1. Arrays

1
Index:   0     1     2     3     4
2
        +-----+-----+-----+-----+-----+
3
Array = |  10 |  20 |  30 |     |     |
4
        +-----+-----+-----+-----+-----+

Contiguous memory layout:

1
[ A ][ B ][ C ][ D ][ E ]

2. Linked Lists (Singly Linked List)

1
Head
2
  |
3
  v
4
+------+    +------+    +------+    +------+
5
|  10  | -> |  20  | -> |  30  | -> |  40  | -> NULL
6
+------+    +------+    +------+    +------+

Node structure conceptually:

1
+-----------+
2
| data | next ---->
3
+-----------+

3. Hash Maps

Key → value mapping:

1
"apple"  ->  5
2
"banana" ->  3
3
"grape"  ->  8

Internal bucket representation (with hashing):

1
Index
2
  0  ->  NULL
3
  1  ->  ("banana", 3)
4
  2  ->  NULL
5
  3  ->  ("apple", 5) -> ("grape", 8)
6
  4  ->  NULL

Conceptually:

1
Key ----hash----> Bucket ----> Value

4. Stacks (LIFO)

1
        +------+
2
Top ->  |  30  |
3
        +------+
4
        |  20  |
5
        +------+
6
        |  10  |
7
        +------+

After push(40):

1
        +------+
2
Top ->  |  40  |
3
        +------+
4
        |  30  |
5
        +------+
6
        |  20  |
7
        +------+
8
        |  10  |
9
        +------+

5. Queues (FIFO)

1
Front                          Rear
2
  |                              |
3
  v                              v
4
+------+    +------+    +------+    +------+
5
|  10  | -> |  20  | -> |  30  | -> |  40  |
6
+------+    +------+    +------+    +------+

Dequeue removes from front.

6. Trees (Binary Tree Example)

1
            10
2
           /  \
3
         5      15
4
        / \       \
5
       2   7       20

General tree structure:

1
        Root
2
        / |  \
3
      N1  N2  N3
4
     / \        \
5
   N4  N5        N6

7. Graphs

Undirected graph:

1
     (A) ----- (B)
2
      |  \       |
3
      |    \     |
4
     (C)     ---- (D)

Directed graph:

1
(A) --> (B)
2
 ^        |
3
 |        v
4
(D) <-- (C)

Adjacency list representation:

1
A: B, C
2
B: D
3
C: D
4
D: A

For which Python type to use (list, dict, set, deque, heapq), see Python Data structures.