Computer Science Visualizations
Interactive computer science visualizations — understand algorithms, data structures, binary, boolean logic, and recursion through step-by-step animations.
45 interactive computer science concepts, each a step-by-step animation you can control, with a short quiz to check what you learned. Topics covered: Data Structures, Algorithms, Systems & Theory, Algorithms & Data Structures, Machine Learning, Fundamentals, Databases, Foundations and Quantum Computing.
Data Structures (14)
- B-Tree — A wide, shallow tree that turns a linear search into a few page reads (intermediate)
- Binary Search Trees — Ordered Data, Fast Lookups — Watch values find their place in a tree that keeps everything sorted (intermediate)
- Bloom Filter — A bit array that can say "definitely not" or "maybe" — never "definitely yes" (intermediate)
- Database Index — Why some queries read one page and others read every page (intermediate)
- Hash Tables: Hash Functions, Buckets and Collisions — Hash a key, jump straight to its bucket, and watch collisions chain (intermediate)
- Inverted Index — A map from every word to the documents that contain it (intermediate)
- Linked Lists — Pointers & Connections — Build a chain of nodes, watch pointers redirect during insertion and deletion, switch to a doubly linked list, and compare what each operation costs a list versus an array (beginner)
- Merkle Trees — Verifying Data with Hashes of Hashes — Hash every data block, then hash pairs of hashes up to a single root, so one short proof shows a block belongs without sending the rest of the data (intermediate)
- Quadtree — Click points into a square that splits into four when crowded, then watch a query skip every quadrant it cannot touch (intermediate)
- R-Tree — Nested boxes that let a spatial search skip everything that cannot possibly overlap — drag the query window and count the boxes it prunes (intermediate)
- Ring Buffers — A Queue That Wraps Around — Store a queue in a fixed row of slots bent into a circle, where the head and tail indices step forward with (i + 1) mod N and wrap from the last slot back to slot 0 (beginner)
- Skip Lists — Express Lanes Through a Sorted List — Stack express lanes above a sorted linked list with coin flips, then watch a search run right along the top lane and drop down a level whenever the next key would overshoot (intermediate)
- Trie — Prefix Trees for Fast Lookup — Fast prefix lookups by sharing the common paths between words (intermediate)
- Union-Find — Merging Disjoint Sets — Track which elements belong together with a forest of parent pointers that answers in nearly constant time (intermediate)
Algorithms (13)
- Amortized Analysis — Averaging Cost Over Time — Some pushes into a growing array are expensive — see why the cost per push still averages out to a small constant (advanced)
- Big O Notation — How to measure and compare the efficiency of algorithms as input grows (intermediate)
- Binary Search — Find any element in sorted data in O(log n) time (beginner)
- Cellular Automata — How one simple rule, applied to a grid of on/off cells, produces gliders, oscillators, and lifelike complexity (beginner)
- Dijkstra's Algorithm — Shortest Paths on Weighted Graphs — Settle the closest node, relax its edges, repeat — watch tentative distances drop until every shortest route is known (intermediate)
- Dynamic Programming — Solve complex problems by breaking them into overlapping subproblems (advanced)
- Graph Theory — Nodes, Edges & Connections — Drag nodes, make edges one-way, read the adjacency list, and watch BFS and DFS fill a live queue and stack (intermediate)
- Graph Traversal — BFS and DFS — two ways to explore a graph (intermediate)
- Greedy Algorithms — Local Choices, Global Optimum — Take the best-looking choice at every step — and see exactly when that solves the whole problem and when it falls short (intermediate)
- Minimum Spanning Tree — Connecting Everything at Least Cost — Join every vertex with the cheapest set of edges — watch Kruskal work down a sorted edge list and Prim grow one tree outward (intermediate)
- Recursion — Functions That Call Themselves — How a function can solve a problem by solving a smaller version of itself (intermediate)
- Sorting — Putting Things in Order — How computers compare and rearrange data, step by step (beginner)
- Topological Sort — Ordering Dependencies — Line up tasks so every task comes after everything it depends on — and spot the cycle that makes it impossible (intermediate)
Systems & Theory (7)
- Concurrency & Race Conditions — Watch two threads add 1 to the same counter, lose an update, and fix it with a lock (intermediate)
- Consistent Hashing — Consistent Hashing — Spreading Keys Across Servers: hash keys and servers onto one ring so adding a server moves only a fraction of the keys (advanced)
- Public-Key Cryptography — RSA Encryption — Watch how two keys — one public, one private — let strangers share secrets (advanced)
- Finite State Machines — One state at a time — watch a simple machine make decisions (beginner)
- Memory Management — Watch function frames push and pop on the stack while heap blocks are allocated, leaked, freed and collected (intermediate)
- Network Protocols (TCP/IP) — Follow one message down four protocol layers, across a lossy link as packets, and back up again (intermediate)
- Regular Expressions & Automata — Watch a pattern become a machine that reads text one character at a time (intermediate)
Algorithms & Data Structures (3)
- Heap & Priority Queue — Building Order from the Bottom Up — Watch one array and its tree side by side as each value sifts down into place — then drain out in sorted order (intermediate)
- Huffman Coding — Compressing text by giving common letters short codes and rare ones long ones (intermediate)
- Stacks & Queues — Same container, same insert end — one rule for what comes back out first (beginner)
Machine Learning (3)
- Decision Trees — Learning to Classify — Grow a tree split by split, read the Gini score of every question it asks, and watch depth turn into overfitting (beginner)
- Gradient Descent — How Machines Optimize — Watch a ball roll downhill on a loss landscape, guided by the gradient toward the minimum (intermediate)
- Neural Networks — How Machines Learn Patterns — Step one training sample through a real network phase by phase, then watch the loss fall epoch after epoch (advanced)
Fundamentals (2)
- Binary Numbers — How Computers Count — Why computers use 0s and 1s, and how they represent any number (beginner)
- Data Storage — How Bits Become Files — How bits become bytes, files, and memory (beginner)
Databases (1)
- Zone Map — Skipping whole pages by remembering only their smallest and largest value (intermediate)
Foundations (1)
- Boolean Logic — The Language of Computers — How AND, OR, and NOT gates make every decision a computer ever makes (beginner)
Quantum Computing (1)
- Quantum Gates — Building Circuits from Qubits — Place X, H and CNOT gates on two qubit wires and watch the state vector and the measurement probabilities change gate by gate (advanced)