Learn data structures and algorithms, end to end

Variables, control flow, I/O, functions, and arrays in C++, Java, JavaScript, and Python.

Big-O notation, common growth classes, how to reason about loops, recursion, and amortized costs.

Hash maps, hash sets, frequency counting, the classic two-sum pattern.

Selection, bubble, insertion. Quadratic but instructive.

Merge sort, quick sort. The recursive sorts that get you to O(n log n).

Kadane, Dutch national flag, majority element, set matrix zeroes, rotations.

Merge intervals, count inversions, median of two sorted arrays, reverse pairs.

Classic lower bound, upper bound, first and last occurrence, rotated arrays.

Search over a range of possible answers. Aggressive cows, koko eating bananas, painter's partition.

Row-column elimination, treating a matrix as a flattened sorted array.

Reverse, palindrome check, anagram check, longest common prefix.

Roman to integer, group anagrams, longest substring without repeating, sort by frequency.

Prev + next pointers. The data structure behind LRU caches and browser history.

Floyd's cycle detection, merge two sorted, remove nth from end, palindrome check, intersection.

Reverse in k-groups, copy list with random pointer, sort, flatten a multilevel list.

Print 1 to N, factorial, sum of N, recursion tree intuition.

Power set, subsequences with sum K, count subsequences, the take-or-skip pattern.

N-queens, sudoku solver, rat in a maze, word break, palindrome partitioning.

AND, OR, XOR, shift, set/clear/toggle the i-th bit.

Count set bits, single non-repeating, XOR of range, power of two, n divisors.

Implementations using arrays and linked lists. Stack from queues, queue from stacks.

Next greater element, daily temperatures, largest rectangle in histogram, sum of subarray minimums.

Sliding window maximum, the classic monotonic deque pattern.

Pair sum on a sorted array, three sum, remove duplicates, container with most water.

Longest substring without repeating, max consecutive ones, minimum window substring, fruits into baskets.

Heapify, sift up, sift down, build heap in O(n), implement a priority queue from scratch.

K largest elements, K closest points to origin, K-th smallest in a sorted matrix, top K frequent.

Two-heap median, merge K sorted lists, the two-heap pattern.

Assign cookies, lemonade change, valid parenthesis after replacements.

N meetings in one room, minimum platforms, job sequencing for max profit.

Fractional knapsack, jump game I and II, candy distribution, minimum coins.

Preorder, inorder, postorder (recursive and iterative). Level order BFS. Morris traversal.

Height, diameter, balanced check, identical trees, symmetric trees, max path sum.

Build a tree from traversals, top/bottom/left/right views, vertical order traversal.

LCA in a binary tree, LCA in a BST, k-th ancestor with binary lifting.

Search, insert, delete, ceiling, floor, k-th smallest, validate BST.

Recover a BST, merge two BSTs, pair sum in a BST, BST iterator with O(h) memory.

Adjacency list vs matrix, directed vs undirected, edge list, when to use each.

Traversal templates, connected components, cycle detection, bipartite check.

Kahn's algorithm and DFS-based, course schedule, alien dictionary.

Dijkstra, Bellman-Ford, Floyd-Warshall, 0/1 BFS, shortest path in DAG.

Prim's and Kruskal's. Why MSTs matter and how to spot them in problem statements.

Union by rank, path compression, the data structure that makes Kruskal's fast and unlocks Number of Islands II.

Strongly connected components, bridges in a graph, articulation points. Disc/low time intuition.

Fibonacci, climbing stairs, frog jump, max sum of non-adjacent, house robber.

Unique paths, min path sum, triangle, chocolate pickup.

Subset sum, partition, target sum, count subsets, the take-or-skip pattern with memoization.

0/1 knapsack, unbounded knapsack, coin change I and II, rod cutting.

O(n^2) DP, O(n log n) binary search variant, printing the LIS, longest divisible subset.

Longest common subsequence, edit distance, shortest common supersequence, wildcard matching.

All six stock problems with one unified state machine.

Matrix chain multiplication, palindrome partitioning, burst balloons, boolean evaluation.

Tree diameter via DP, max path sum, house robber on a tree, rerooting technique.

Insert, search, starts-with. Build the data structure from scratch.

Max XOR of two numbers, count distinct substrings, word search II.

Knuth-Morris-Pratt failure function. Substring matching in O(n + m).

Z-function. Pattern matching, string period detection.

Rabin-Karp, polynomial hashing, double hashing to defeat anti-hash tests.

Longest palindromic substring in O(n).

GCD by Euclid's algorithm, LCM, sieve of Eratosthenes, prime factorization.

Modular addition, multiplication, inverse via Fermat's little theorem, fast exponentiation.

nCr mod p, Pascal's triangle, stars and bars, basic counting.

Build, point update, range query. Sum, min, max segment trees.

Range updates with lazy propagation. The pattern that turns O(n*q) into O((n+q) log n).

Binary indexed tree, prefix sums in O(log n), counting inversions in O(n log n).

Hash map + doubly linked list. The most-asked design problem in interviews.

Frequency tracking with O(1) operations. Hash map + nested doubly linked list.

Time-based key-value store, snapshot array, randomized set, design Twitter.