DSA Curriculum — 29 Topics · 6 Categories
Master Data Structures
& Algorithms.
Live canvas animations, optimized Python code, Big-O for every topic, and 47+ curated interview problems tagged for FAANG and startups. The most visual DSA reference — free.
⬡Live Canvas animations
⬡Python implementations
⬡Big-O every topic
⬡FAANG + Startup tagged
29TopicsStructures + Algorithms
6CategoriesLinear to Advanced
47+ProblemsFAANG & Startup tagged
LiveAnimationsCanvas 2D, 60fps
O(?)ComplexityEvery topic analyzed
Recommended Learning Path
Foundations
What exactly is DSA?
The two concepts every strong engineer understands cold.
Data Structure
A container that stores and organizes data — like a list of numbers, a stack of plates, or a tree of folders. The right structure makes operations fast; the wrong one makes them sluggish.
Algorithm
A step-by-step procedure to solve a problem. Like a recipe — precise, repeatable, and measurable in time and memory cost. The same problem can have wildly different algorithms.
Time Complexity
How runtime grows as input grows. The gap between O(n) and O(n²) is the gap between "scales fine" and "unusable in production." Big-O is the language engineers use to discuss this.
Space Complexity
How much memory an algorithm consumes. Critical in constrained environments — mobile apps, embedded systems, or any service handling millions of requests per second.
Strong DSA skills mean better code, faster debugging, and the ability to reason about performance before problems appear in production — not just on whiteboards.
Quick Reference
Big-O Complexity at a Glance
From fastest to slowest — how algorithms scale with input size n.
Reference Table
Sorting Algorithm Complexities
Best, average, worst case — and space usage side by side.
| Algorithm | Best Case | Average Case | Worst Case | Space | Stable? |
|---|---|---|---|---|---|
| Bubble Sort | O(n) | O(n²) | O(n²) | O(1) | ✓ Yes |
| Selection Sort | O(n²) | O(n²) | O(n²) | O(1) | ✗ No |
| Insertion Sort | O(n) | O(n²) | O(n²) | O(1) | ✓ Yes |
| Merge Sort | O(n log n) | O(n log n) | O(n log n) | O(n) | ✓ Yes |
| Quick Sort | O(n log n) | O(n log n) | O(n²) | O(log n) | ✗ No |
| Heap Sort | O(n log n) | O(n log n) | O(n log n) | O(1) | ✗ No |
Reference Table
Data Structure Operation Complexities
Average and worst case for core operations — at a glance.
| Data Structure | Access | Search | Insert | Delete | Space |
|---|---|---|---|---|---|
| Array | O(1) | O(n) | O(n) | O(n) | O(n) |
| Linked List | O(n) | O(n) | O(1) | O(1) | O(n) |
| Stack | O(n) | O(n) | O(1) | O(1) | O(n) |
| Queue | O(n) | O(n) | O(1) | O(1) | O(n) |
| Hash Table | N/A | O(1)* | O(1)* | O(1)* | O(n) |
| BST (balanced) | O(log n) | O(log n) | O(log n) | O(log n) | O(n) |
| Heap | O(1)** | O(n) | O(log n) | O(log n) | O(n) |
| Graph (adj list) | N/A | O(V+E) | O(1) | O(V+E) | O(V+E) |
* Average case. Worst case O(n) with collisions. ** Peek at min/max only.
Interview Strategy
What to focus on — FAANG vs Startup
Not all DSA is weighted equally. Know your target before you prep.
Real World
DSA powers everything you use
Every system you interact with daily relies on the same concepts covered here.
Graphs + Hashing
Search Engines
PageRank + hash tables index billions of pages for millisecond results.
Dijkstra's
GPS Navigation
Finds shortest paths between millions of road nodes in real time.
Trees + Hashing
E-commerce
Power product search, inventory systems, and recommendation engines.
Number Theory
Cryptography
RSA and elliptic curve algorithms protect every online transaction.
Graph Traversal
Social Networks
BFS/DFS powers friend suggestions and connection analysis at scale.
B+ Trees
Databases
The index structure behind MySQL, PostgreSQL, and MongoDB queries.
Full Curriculum
All 29 DSA Topics
Start from the top and work down, or jump to what you need.
Linear Data Structures
Sequential storage — the essential building blocks
Big-O Notation
Measure algorithm efficiency with time and space complexity.
Arrays & Strings
Contiguous memory, indexing, and essential string operations.
Singly Linked List
Nodes with one-directional pointers. Insertion and deletion demystified.
Doubly Linked List
Bi-directional traversal — prev and next pointers together.
Circular Linked List
The tail connects back to the head — endless loops, tamed.
Stack
LIFO structure. Push, pop, peek — the backbone of undo and recursion.
Queue & Deque
FIFO processing and the double-ended variant. Critical for BFS.
Non-Linear Data Structures
Hierarchical & networked — where real complexity lives
Binary Search Tree
Ordered tree for O(log n) search, insert, and delete.
AVL Tree
Self-balancing BST — rotations keep height O(log n) guaranteed.
Heap
Min/Max heap — the engine behind priority queues and heap sort.
Trie
Prefix tree for O(L) string lookups. Powers autocomplete.
Graphs
Vertices + edges — directed, undirected, weighted, cyclic.
Hash Table
O(1) average lookup via hash functions and collision handling.
Sorting Algorithms
Ordering data — from brute force to elegant divide & conquer
Bubble Sort
Adjacent swaps — simple, O(n²), the classic starting point.
Selection Sort
Find the minimum, place it — always O(n²) regardless of input.
Insertion Sort
Build sorted array one item at a time. O(n) on nearly-sorted data.
Merge Sort
Divide, sort, merge — guaranteed O(n log n), stable sort.
Quick Sort
Pivot-based partition — fast in practice, O(n²) worst case.
Heap Sort
Selection sort upgraded with a max-heap. O(n log n), in-place.
Searching Algorithms
Finding what you need — fast
Graph Algorithms
Traversal, pathfinding & shortest paths
Problem-Solving Techniques
Patterns that unlock 80% of interview problems
Recursion
Break problems into smaller self-similar subproblems. Base cases, call stack.
Dynamic Programming
Memoize overlapping subproblems. Turn exponential into polynomial.
Two Pointer
Two indices that move toward each other. Classic: pair sum, palindrome.
Sliding Window
Maintain a moving subarray. Turns O(n²) brute force into O(n).
Bit Manipulation
AND, OR, XOR, shifts — often the clevest O(1) solution in an interview.