Home / Explore / Computer Science

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)

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)

Machine Learning (3)

Fundamentals (2)

Databases (1)

  • Zone Map — Skipping whole pages by remembering only their smallest and largest value (intermediate)

Foundations (1)

Quantum Computing (1)