A comprehensive interactive exploration of 36 algorithms — 10 sorting, 6 searching, 9 graph, 4 DP, 2 greedy, 2 backtracking, and 3 string matching — with step-by-step animation, Big-O analysis, and practical comparisons.

Master the most fundamental data structures: contiguous memory arrays and immutable string manipulation. Covers traversal, two-pointer techniques, and common string algorithms.

Understand singly and doubly linked lists, their traversal patterns, and trade-offs against arrays. Covers reversal, cycle detection, and merge operations.

Master asymptotic notation for algorithm analysis. Covers O, Ω, Θ notations, common complexity classes, and how to analyze iterative and recursive algorithms.

Understand recursive problem-solving: base cases, recursive cases, the call stack, and common recursive patterns like divide-and-conquer and backtracking.

Learn to model recursive algorithms with recurrence relations and solve them using substitution, recursion trees, and the Master Theorem.

Master Divide and Conquer — breaking problems into independent subproblems, solving them recursively, and combining results. The engine behind Merge Sort, Quick Sort, and Binary Search.

Explore the LIFO (Last-In-First-Out) stack data structure — operations, array vs linked-list implementations, and common applications like expression evaluation and undo systems.

Explore the FIFO (First-In-First-Out) queue data structure — enqueue, dequeue, front, circular buffers, and applications like BFS and task scheduling.

Understand hash tables and hash maps — hash functions, collision handling (chaining vs open addressing), load factor, resizing, and real-world applications.

Understand binary heaps (min-heap, max-heap), heap operations, heapify, heap sort, and priority queue implementations.

Master the two-pointer technique and the sliding-window pattern — two of the most reusable tricks for turning O(n²) substring problems into O(n) algorithms.

Learn the greedy strategy — making the locally optimal choice at each step — and how to prove it produces a globally optimal solution.

Master Dynamic Programming — the art of breaking problems into overlapping subproblems, storing their answers, and reconstructing optimal solutions.

Master backtracking — systematically searching for solutions by building candidates incrementally and abandoning them the moment they violate constraints.

Master the linear-time algorithms that locate a pattern inside a larger text — from naive scanning to KMP, Rabin-Karp, and the Z-algorithm.

The Disjoint Set Union — find and union in effectively O(1), the engine behind Kruskal's algorithm, dynamic connectivity, and cycle detection.

Understand how graphs are stored in memory using adjacency matrices and adjacency lists, and when to choose each representation.

Master Breadth-First Search and Depth-First Search — the foundational graph traversal algorithms used in pathfinding, cycle detection, topological sorting, and more.

Learn Dijkstra's algorithm — the gold-standard greedy algorithm for finding shortest paths from a single source in graphs with non-negative edge weights.

Explore Prim's and Kruskal's algorithms for finding Minimum Spanning Trees — the optimal network that connects all nodes with minimum total edge weight.

The trie — a character-keyed prefix tree where lookups and inserts cost O(word length), the data structure behind autocomplete, spell checkers, and IP routing.

The Fenwick tree (Binary Indexed Tree) — prefix sums and point updates in O(log n) with a few lines of code, the lowbit trick behind counting inversions and order statistics.

A* — the informed search algorithm that combines Dijkstra's real costs with a heuristic, finding optimal paths on grids and graphs by expanding f = g + h.

Bit manipulation — the fundamental toolkit of low-level and competitive programming: bitwise operators, masks, lowbit tricks, and the classic bit-trick algorithm families.

The Segment Tree — O(log n) range queries and point updates over an array, the workhorse of dynamic range-statistics problems.

The AVL tree — the first self-balancing BST, keeping height O(log n) with balance factors and rotations, the strictest height guarantee of all balanced trees.

The Red-Black tree — the self-balancing BST behind every standard library ordered map, balancing with colors, recoloring, and rotations in O(log n).

The B-Tree — the self-balancing multi-key search tree engineered for disk blocks and database indexes, keeping billions of keys just a few levels deep.

The sparse table — precomputed power-of-two intervals that answer static range minimum/maximum/GCD queries in O(1) after O(n log n) preprocessing.

LCA with binary lifting — precompute 2^k-th ancestors in O(n log n), then answer any LCA, k-th-ancestor, or tree-distance query in O(log n).

Mathematical algorithms — modular arithmetic, exponentiation, gcd/euclid, sieve, primality, and combinatorics — the number-theoretic toolkit behind hashing, cryptography, and competitive programming.

Maximum flow with Edmonds-Karp — BFS augmenting paths in the residual graph, the max-flow/min-cut theorem, and applications from bipartite matching to image segmentation.

Computational complexity theory — P, NP, reductions, NP-hardness, and NP-completeness — the theory that classifies problems by intrinsic difficulty and frames the biggest open question in computer science.