Home / Learn / Data Structures

🧱 Data Structures

Organizing data for efficient access. 52 topics, from beginner to advanced.

Data structures are the ways programs organize information in memory so it can be read, changed and searched efficiently. Arrays, linked lists, stacks, queues, trees, heaps, hash tables and graphs each make different operations fast and others slow. Choosing the right one is often the single biggest factor in a program’s speed.

Who this area is for

Learners who can write basic programs and now want to write faster, cleaner code, and anyone preparing for technical interviews.

Real-world use cases

Using a hash table to look up users by ID in constant average time.
Using a stack to track function calls or undo history.
Using a heap to repeatedly get the highest-priority task in a scheduler.
Choosing a priority queue for a job scheduler that always runs the most urgent task.
Using a trie to power autocomplete in a search box.

Topics in Data Structures

Beginner (18)

Arrays — Contiguous memory blocks giving constant-time indexed access.
Dynamic Arrays — Resizable arrays that grow by reallocating with amortized cost.
Linked Lists — Nodes chained by pointers allowing cheap insertion and removal.
Doubly Linked Lists — Linked nodes with both next and previous pointers.
Circular Linked Lists — Lists where the last node points back to the first.
Stacks — Last-in first-out collection with push and pop.
Queues — First-in first-out collection with enqueue and dequeue.
Deque — Double-ended queue permitting insertion and removal at both ends.
Priority Queue — Collection always yielding the element with highest priority first.
Hash Tables — Structures mapping keys to buckets via a hash function.
Hash Collisions — Situations where distinct keys map to the same slot.
Chaining — Collision strategy storing colliding entries in per-bucket lists.
Open Addressing — Collision strategy probing other slots in the table itself.
Trees — Hierarchical structures of nodes with parent-child relationships.
Binary Trees — Trees where each node has at most two children.
Tree Traversals — Visiting nodes in preorder, inorder, postorder or level order.
Binary Search Trees — Ordered binary trees with left smaller and right larger keys.
AVL Trees — Self-balancing BSTs keeping subtree heights within one.

Intermediate (17)

Red-Black Trees — Balanced BSTs using node colors to bound height.
B-Trees — Wide balanced trees optimized for disk block access.
B+ Trees — B-tree variant storing all data in linked leaves, common in databases.
Heaps — Complete trees satisfying a parent-versus-child ordering property.
Binary Heap Operations — Sift-up and sift-down procedures maintaining the heap invariant.
Tries — Prefix trees storing strings character by character.
Segment Trees — Trees answering range queries and updates in logarithmic time.
Fenwick Trees — Compact structure for prefix sums with point updates.
Graphs — Vertices connected by edges modeling relationships.
Adjacency List — Graph storage keeping each vertex's neighbors in a list.
Adjacency Matrix — Graph storage using a square grid marking edges.
Disjoint Set Union — Structure tracking partitions with union and find operations.
Path Compression — Flattening find paths to speed up disjoint sets.
Skip Lists — Layered linked lists enabling probabilistic logarithmic search.
Bloom Filters — Probabilistic set membership structure allowing false positives only.
Splay Trees — Self-adjusting trees moving accessed nodes to the root.
Treaps — Randomized trees combining BST order with heap priorities.

Advanced (17)

Sparse Tables — Precomputed tables answering idempotent range queries in constant time.
Suffix Arrays — Sorted array of all suffixes of a string.
Suffix Trees — Compressed trie of all suffixes enabling fast substring queries.
Interval Trees — Trees storing ranges to find overlaps efficiently.
KD-Trees — Space-partitioning trees for multidimensional points.
Quadtrees — Trees recursively dividing two-dimensional space into four regions.
LRU Cache Structure — Hash map plus linked list evicting least recently used entries.
Circular Buffer — Fixed-size ring storing streaming data with wrapping indices.
Persistent Data Structures — Structures preserving previous versions after updates.
Fibonacci Heaps — Heaps with amortized constant decrease-key operations.
Van Emde Boas Trees — Structures supporting integer set operations in log-log time.
Cuckoo Hashing — Hashing scheme with two tables guaranteeing constant lookup.
Count-Min Sketch — Probabilistic frequency estimator using little memory.
HyperLogLog — Probabilistic counter estimating distinct elements.
Merkle Trees — Hash trees enabling efficient integrity verification.
Rope Data Structure — Tree of string pieces for efficient large text editing.
Union of Sets with Bitsets — Compact boolean arrays operating on many bits at once.

How to study Data Structures

For each structure, ask what the common operations cost and why. Implement a small version yourself, such as a stack or a hash table, before you use the built-in one. Use the Visual Lab stack, queue, BST and hash views to watch operations change the structure step by step.

Frequently asked questions

Array or linked list: which is better?

Arrays give fast indexed access and good cache locality. Linked lists give cheap insertion and removal once you hold a reference to the node. Arrays win in most real workloads.

What is the difference between a stack and a queue?

A stack is last-in, first-out (LIFO), like a pile of plates. A queue is first-in, first-out (FIFO), like a checkout line.

When should I use a tree instead of a hash table?

Use a tree when you need ordered data, range queries or the minimum and maximum. Hash tables are faster for exact lookups but do not keep keys in order.

Do I need to implement data structures from scratch?

Implementing a few of them, such as a linked list, a stack and a binary search tree, builds understanding. In production code you will usually use the libraries that your language provides.

Which data structure should I learn first?

Start with arrays and then stacks, queues and hash tables. These appear in almost every program and make the later structures easier to follow.

Open the interactive Data Structures area Take the Data Structures quiz