How to Read This
Each node is a concept, and each line runs from a prerequisite down into whatever builds on it next — so following the curves top to bottom roughly traces the order I'm working through it myself, video by video.
Arrays & Strings
The building blocks — indexing, traversal, and common manipulation patterns.
Recursion Basics
Functions that call themselves — base cases, call stacks, thinking recursively.
Big-O & Complexity
Measuring time and space complexity to compare algorithm efficiency at scale.
Linked Lists
Singly and doubly linked lists, pointer manipulation, and when they beat arrays.
Stacks & Queues
LIFO and FIFO structures for parsing, backtracking, and ordered processing.
Hash Tables
Hashing, collision handling, and O(1) average lookups for fast key-value access.
Two Pointers & Sliding Window
Scanning arrays and strings in linear time with two-pointer and window techniques.
Sorting Algorithms
Comparison and non-comparison sorts — merge, quick, heap, and counting sort.
Bit Manipulation
Bitwise operators, masks, and tricks for compact, fast low-level computation.
Binary Trees
Hierarchical structures, traversals (in/pre/post-order), and recursive tree thinking.
Binary Search
Halving the search space on sorted data, and its many disguised variants.
Divide & Conquer
Breaking a problem into subproblems, solving recursively, combining the results.
Binary Search Trees
Ordered trees supporting fast search, insert, and delete — and where they degrade.
Heaps & Priority Queues
Binary heaps for fast access to the min or max element in a collection.
Tries
Prefix trees for fast string search, autocomplete, and dictionary-style lookups.
Graph Representations
Adjacency lists and matrices, and directed vs. undirected graphs.
Dynamic Programming
Solving overlapping subproblems with memoization and tabulation.
Backtracking
Exploring choices recursively and undoing them at a dead end.
Greedy Algorithms
Making locally optimal choices and proving when that reaches a global optimum.
Balanced Trees
Self-balancing trees (AVL, red-black) that keep operations logarithmic worst-case.
BFS & DFS
Breadth-first and depth-first traversal for exploring graphs and trees.
Union-Find
Disjoint-set structures for tracking connected components with near-O(1) merges.
Segment & Fenwick Trees
Fast range queries and updates over an array.
Topological Sort
Ordering nodes in a DAG so every dependency comes before what depends on it.
Shortest Paths
Dijkstra's and Bellman-Ford for shortest paths in weighted graphs.
Minimum Spanning Trees
Kruskal's and Prim's algorithms for connecting a graph at minimum total weight.