Computer Science
171 articles in this category.
Sorting Algorithms
Visualizing how data is ordered.
A* Pathfinding
Finds the shortest path on a grid using heuristics.
Binary Search
Finding elements in sorted data by halving the search space.
Dijkstra's Algorithm
Finding the shortest path in a weighted graph by greedily exploring the nearest unvisited node.
Graph Traversal (BFS/DFS)
Visualize how Breadth-First and Depth-First Search algorithms navigate through graph data structures.
Convex Hull
Convex Hull
Dynamic Programming
Dynamic Programming
Finite State Machine
Finite State Machine.
Stack & Queue
Fundamental linear data structures enforcing LIFO and FIFO access patterns.
Tree Traversal
Tree Traversal
Heap & Priority Queue
Heap & Priority Queue.
Linked List Operations
Visualize dynamic memory allocation through node insertion, deletion, and traversal.
RSA Encryption
Visualizes RSA key generation, modular exponentiation, and the flow between public and private key encryption/decryption.
Topological Sort
Visualize Kahn's algorithm and DFS for finding linear orderings of directed acyclic graphs.
Regular Expression Engine
Visualize how regular expressions are parsed and evaluated against text strings.
Trie (Prefix Tree)
Visualize string insertion, exact matching, and prefix search operations within a Trie data structure.
AVL Tree Rotations
Visualize self-balancing binary search trees through balance factors and rotations.
Bloom Filter
Visualize Bloom Filter element insertion, hash function mapping, and false positive probability.
Floyd-Warshall Algorithm
Visualize the dynamic programming approach to finding shortest paths between all pairs of vertices in a weighted graph.
Huffman Coding
Visualize character frequencies, tree building, and prefix-free encoding.
LRU Cache
Visualize the Least Recently Used (LRU) cache eviction policy.
Minimum Spanning Tree
Visualize Kruskal's algorithm finding the minimum spanning tree of an edge-weighted graph.
Red-Black Tree
Visualize self-balancing binary search trees through nodes and recoloring.
Skip List
Visualize multi-level linked list operations with probabilistic balancing.
Union-Find (Disjoint Set)
Visualize how the Union-Find data structure efficiently tracks and merges disjoint sets.
B-Tree Visualization
Visualize B-Tree node splitting, key insertion, and tree balancing with customizable degree parameters.
Knapsack Problem
Optimize resource allocation by maximizing total value within a given weight capacity constraint.
Network Flow (Max-Flow)
Visualize how the maximum flow in a network is calculated using augmenting paths.
Rabin-Karp String Search
Visualize the rolling hash and matching process of the Rabin-Karp algorithm.
Segment Tree
Visualize how segment trees enable efficient range queries and point updates in logarithmic time.
Bellman-Ford Algorithm
Visualize the shortest path algorithm that handles negative edge weights by relaxing all edges in V-1 iterations.
Consistent Hashing
Visualize consistent hashing with virtual nodes for distributed caching and load balancing.
K-D Tree
Visualize the construction of a K-D tree and nearest neighbor search in 2D space.
Radix Sort
Visualize how integer arrays are sorted digit by digit using counting sort as a subroutine.
Suffix Array
Visualize suffix sorting, lexicographical ordering, and efficient substring searching using an array of suffix indices.
Counting Sort
Visualize Counting Sort with counting array and placement.
Fenwick Tree (BIT)
Visualize how a Binary Indexed Tree enables efficient prefix sums and point updates.
Splay Tree
Visualize a self-adjusting search tree that moves recently accessed elements to the root.
PageRank Algorithm
Visualize the iterative calculation of network node importance using the PageRank algorithm with adjustable damping factor and speed.
KMP String Matching
Build a prefix-suffix table and replay exact string search with fallback, overlapping matches and a text cursor that never rewinds.
Hamming Error Correction
Encode Hamming and extended SECDED words, flip channel bits, and explore parity syndromes, recovery and multi-error limits.
Chinese Remainder Theorem
Combine two remainder patterns, construct their shared residue class, and see when common factors make the conditions compatible or impossible.
Shamir Secret Sharing
Split a secret into finite-field polynomial shares, reconstruct it with a threshold, and show why fewer shares leave every secret possible.
Aho-Corasick Multi-Pattern Matching
Build a dictionary automaton and replay one-pass text search with failure links, inherited suffix outputs and every overlapping match.
Levenshtein Edit Distance
Reveal prefix edit costs, compare insertion/deletion/substitution candidates and trace one optimal string alignment.
Strongly Connected Components
Partition a directed graph by mutual reachability, replay two-pass DFS and contract its strongly connected components into a DAG.
Bipartite Matching
Build one-to-one pairings, preview alternating reassignment paths and distinguish a maximum matching from a maximal or perfect one.
Extended Euclidean Algorithm
Replay exact integer divisions, track Bézout coefficients and discover when a gcd certificate produces a modular inverse.
Articulation Points
Remove a vertex to test network resilience, compare connected components and replay the DFS low-value certificate with its special root rule.
Interval Scheduling
Scan jobs by finish time, compare compatible half-open intervals and build a maximum-count schedule.
Multiplicative Persistence
Trace exact decimal digit products, inspect every iteration, and distinguish persistence from the final digit with single-digit and zero-containing boundaries.
Stable Matching (Gale–Shapley)
Edit two-sided preferences, replay deferred acceptance, inspect blocking pairs and compare proposer-optimal stable outcomes.
Weighted Interval Scheduling
Maximize the total value of compatible jobs, replay include-or-exclude decisions and discover why earliest-finish greedy can lose.
Reservoir Sampling
One-pass uniform sampling of an unknown stream.
Token Bucket Rate Limiting
Send requests and advance simulated time to distinguish burst capacity, refill rate and strict token-based admission from a queue or fixed-window counter.
Arithmetic Coding
Encode a sequence of symbols as a single nested rational interval within [0, 1).
Boyer–Moore Majority Vote
Replay candidate/counter cancellation, then a distinct full verification pass.
Cyclic Redundancy Check
Calculate Cyclic Redundancy Check (CRC) using polynomial long division over GF(2).
Eulerian Trail
Hierholzer's algorithm for finding Eulerian trails and circuits.
Longest Increasing Subsequence
Visualize the dynamic programming solution for finding the longest increasing subsequence in an array of integers.
Maximum Subarray
Find the contiguous subarray with the largest sum using Kadane's Algorithm.
Minimax and Alpha–Beta Pruning
Trace through a depth-3 minimax game tree, observing how alpha-beta pruning skips branches.
Shunting Yard Algorithm
Convert an infix expression to space-separated postfix using an operator stack.
Sieve of Eratosthenes
Step through composite-marking passes and identify all primes up to a chosen bound.
2-SAT Implication Graph
Build implications and deterministically compute SCCs to solve 2-SAT.
Bipartite Two-Coloring and Odd Cycles
Try to split an arbitrary graph into two sides and inspect an odd-cycle certificate when that is impossible.
DPLL Satisfiability Search
Follow unit implications and backtracking decisions to find a satisfying assignment or prove that none exists.
Hamiltonian Cycles
Search for closed routes that visit every vertex once and compare them with edge-covering Eulerian routes.
Lowest Common Ancestor by Binary Lifting
Trace ancestor jumps to find where two paths toward a tree root first meet.
Manacher Palindrome Radii
Discover how mirror symmetry finds every palindrome radius and the longest palindromic substring.
Miller–Rabin Witnesses
Inspect a modular squaring chain to distinguish a compositeness witness from a base that merely passes.
Next Greater Element with a Monotonic Stack
Watch a decreasing stack resolve the first strictly greater value to the right of each position.
Optimal Binary Search Tree
Rearrange three ordered keys to minimize the weighted number of comparisons for successful searches.
Polynomial GCD over GF(2)
Use binary polynomial division to uncover a common factor and distinguish it from an integer gcd.
Sliding Window Maximum
Move a fixed-size window across a sequence and see which candidate remains its earliest maximum.
Z-Function Prefix Matches
Explore how a shared prefix can reappear inside a string and how a moving window reuses earlier matches.
Banker's Safety Algorithm
Test resource availability against remaining process claims and distinguish a safe completion order from an unsafe state.
Bitonic Sorting Network
Send eight values through a fixed parallel comparator network and inspect each sorting layer.
Bridges in Undirected Graphs
Find edges whose removal disconnects a graph and connect each bridge to a depth-first low-link witness.
Burrows–Wheeler Transform
Reorder a text block into a reversible last column and follow its stable inverse mapping.
Count-Min Frequency Sketch
Estimate stream frequencies with bounded counters and inspect the collisions behind overestimation.
Dual Number Forward Differentiation
Propagate values and directional derivatives through a computation using dual numbers.
Hungarian Assignment
Match three workers to three jobs while comparing assignment cost with a dual certificate of optimality.
HyperLogLog Register Harmonic Estimate
Estimate distinct values from bucketwise leading-zero maxima and a harmonic aggregate.
Line Envelope Convex Hull Trick
Query a lower line envelope while preserving parallel-line and intersection ties.
Longest Common Subsequence
Compare two texts and reconstruct a longest shared subsequence with a deterministic tie rule.
LZW Dictionary Compression
Watch repeated phrases extend a shared dictionary and reconstruct the text from its emitted codes.
Matrix Chain Multiplication
Choose parentheses for four compatible matrices and compare the resulting arithmetic costs.
MinHash Permutation Resemblance
Link minimum permutation ranks to exact set resemblance and finite signature collisions.
Pollard Rho Integer Factorization
Turn collisions modulo unknown factors into a bounded integer-factor search.
Pushdown Automaton for Balanced Brackets
Use a stack to recognize nested round and square brackets and locate the first mismatch.
Reed–Solomon Evaluation Code
Recover a polynomial message from finite-field evaluations corrupted at one position.
Rollback Disjoint Set
Create nested connectivity checkpoints, undo unions and branch into a different future partition.
Undirected Chinese Postman
Repeat the cheapest paths needed to turn edge coverage into a closed route.
Vector Clocks
Compare distributed events by causal ancestry instead of assuming one global timeline.
Viterbi Convolutional Decoding
Trace minimum-distance decoding through a finite-state convolutional-code trellis.
Zobrist Incremental Board Hashing
Cancel and replace piece features to update a board hash incrementally.
Algorithm X Exact Cover
Cover every constraint once while watching reversible search decisions.
Bron–Kerbosch Maximal Cliques
Follow R, P and X to find every maximal clique without confusing maximal with maximum.
Cuckoo Hashing
Follow evicted keys between two hash tables and detect when a rehash is needed.
CYK Context-Free Parse Counts
Count context-free parse trees by combining span charts and grammar rules.
DAG Transitive Reduction
Remove redundant arrows while preserving every directed reachability relation.
De Bruijn Prefer-One Cycle
Visit every binary word once by extending a cyclic sequence greedily.
DFA Equivalence Minimization
Merge states only when no future suffix can distinguish their accepted languages.
Dilworth Chain–Antichain Duality
Match comparabilities to turn an order into the fewest chains.
Directed Graph Dominators
Find vertices that every rooted execution path must pass through.
Duval Lyndon Factorization
Find the unique ordered factorization of a word through Duval's pointer comparisons.
Earley Nullable Chart Parsing
Follow a chart parser through nullable productions, left recursion and ambiguous derivations.
Fast Walsh–Hadamard Transform
Follow add/subtract butterflies through a real binary-basis transform.
Gale–Ryser Binary Matrix Margins
Turn row and column sums into sharp feasibility inequalities for binary matrices.
Greedy Set Cover Certificate
Compare greedy covering decisions with an exact small optimum and a provable approximation certificate.
Hamming Sphere-Packing Bound
Pack Hamming balls to see which error-correcting code sizes are impossible.
Havel–Hakimi Degree Sequences
Peel a degree sequence to construct a graph or expose an impossibility.
Heavy–Light Tree Decomposition
Break tree paths into a few contiguous heavy-chain intervals.
Held–Karp Traveling Salesman
Solve a tiny traveling-salesman instance through subsets and reconstruct the best tour.
Interval Partitioning and Graph Colors
Schedule every interval using the fewest rooms and expose the overlap certificate.
Johnson Potential Reweighting
Use vertex potentials to turn negative edges into a safe nonnegative shortest-path problem.
Karatsuba Multiplication
Replace four half-size products with three and reconstruct an exact integer product.
Kőnig Bipartite Cover Duality
Turn a maximum bipartite matching into a minimum vertex cover with an alternating-path certificate.
Lindström Nonintersecting Paths
Cancel intersecting path families with a determinant and retain signed disjoint witnesses.
Linear Counting Distinct Bitmap
Estimate distinct keys from unoccupied hash buckets and recognize saturation.
Minimal Cyclic String Rotation
Eliminate cyclic starts until only the least rotation remains.
Prüfer Labeled Tree Codes
Remove the smallest leaf to encode a labeled tree and reconstruct it exactly.
Reduced Ordered Binary Decision Diagram
Reduce a Boolean decision graph and see how variable order affects its size.
Robin Hood Hash Displacement
Move crowded keys aside by comparing their probe distances.
Sardinas–Patterson Decodability
Follow suffix states to distinguish prefix-free codes from uniquely decodable ones.
Sethi–Ullman Register Allocation
Choose expression evaluation order to minimize simultaneously live registers.
Sparse Table Range Minimum Query
Answer static range minima by overlapping two precomputed power-of-two blocks.
Sprague–Grundy Subtraction Games
Use mex values to classify subtraction positions and find winning moves.
Stern–Brocot Rational Tree
Find every positive rational through integer mediants and a unique left–right path.
Stoer–Wagner Global Minimum Cut
Contract maximum-adjacency phases to find the lightest cut without choosing terminals.
Strassen Seven-Product Multiplication
Reconstruct a matrix product from seven carefully combined multiplications.
Subset Zeta and Möbius Transform
Accumulate subset sums and reverse them with inclusion–exclusion signs.
Treap Split and Merge
Split and rejoin a search tree while its keys and heap priorities remain consistent.
Zero–One BFS Deque
Put free moves at the front and unit-cost moves at the back.
Cartesian Tree Range Minimum
Turn range minima into lowest common ancestors while preserving duplicate-key order.
Elias Universal Integer Codes
Decode self-delimiting integer lengths and distinguish incomplete headers from valid messages.
FIRST FOLLOW Predictive Tables
Build predictive parsing tables and see how nullable rules and common prefixes affect determinism.
FM-Index Backward Search
Shrink suffix intervals through BWT ranks to locate text patterns.
Johnson–Trotter Adjacent Permutations
Walk through permutations with one adjacent swap per step and track parity.
LFU Resident-Frequency Cache
Compare resident-frequency and recency eviction decisions on the same access stream.
Misra–Gries Frequent Items
Track possible heavy hitters with bounded counters and certify their frequency error.
Shift-And Bit-Parallel Matching
Track all active pattern prefixes with one bitmask while preserving overlapping matches.
Suffix Automaton
Build a compact automaton for all substrings and expose why clone states are needed.
Berlekamp–Massey Binary Complexity
Infer the shortest binary feedback recurrence while tracing discrepancies one bit at a time.
Bidirectional Dijkstra Frontier Stop Certificate
See why the first meeting of two searches is only a candidate and learn the safe stopping bound.
Binomial Heap Meld Carries
Meld heap forests by linking equal degrees like carries in binary addition.
Bitvector Rank–Select Directory
Navigate packed bits by translating between prefix counts and positions of ones.
Burnside Necklace Symmetry
Count colorings up to symmetry while separating fixed configurations, orbits and stabilizers.
Catalan Stack Output Permutations
Count the permutations one stack can emit and expose the first impossible pattern.
Christofides Metric Tour Parity Certificate
Repair a tree’s odd degrees, shortcut an Euler tour and verify a metric route approximation bound.
CUSUM One-Sided Change Detection
Track persistent shifts with accumulated positive deviations and an explicit alarm rule.
Eertree Palindromic Suffix Links
Build one node per distinct palindrome and follow the suffix links that make online updates possible.
Elias–Fano Monotone Select
Split monotone integers into low bits and a select-indexed high-bit vector.
FKS Perfect Hashing Collision Energy
Use bucket collision energy to turn two-level hashing into collision-free lookup.
Hanoi Three-Peg Shortest State Path
Explore legal disk moves and see why a deceptively small puzzle needs exponentially many steps.
Horspool Bad-Character Search
Use an aligned bad-character shift to skip impossible pattern positions.
Josephus Circular Elimination Recurrence
Watch a counting circle shrink and uncover the recurrence that predicts its survivor.
Kaprekar Four-Digit Attractor
Sort four digits in opposite orders and subtract: thousands of starting numbers fall into the same 6174 attractor.
Karger Contraction Success
Count the chance that random edge contractions preserve a minimum cut.
Karp Minimum Mean Cycle
Find the lightest average-weight directed cycle through a dynamic-programming certificate.
LPT Parallel-Machine Load Balance
Balance known job lengths across identical machines and measure greedy scheduling loss.
LZ78 Dictionary Prefix Parsing
A growing dictionary compresses repeated phrases into references, and the final partial phrase needs its own precise rule.
Minimum-Cost Flow Residual Rerouting
Undo an earlier route through residual edges to find the cheapest multi-unit flow.
Morris Inorder Temporary Thread Restoration
Borrow empty tree pointers during traversal and watch every temporary thread get restored.
Myhill–Nerode Distinguishing Suffixes
Visualize how to prove two DFA states are distinct by finding a short binary suffix that leads one state to an accept state and the other to a reject state.
Number-Theoretic Transform Convolution
Compute exact modular convolution and distinguish coefficient wrap from modular reduction.
Roaring Array-Bitmap Container Threshold
See a bitmap switch representation as a set crosses a container threshold or a high-word boundary.
Ski Rental Online Competitive Ratio
Compare an online rent-or-buy rule with an offline decision that knows the season length.
Van Emde Boas High-Low Search
Split an integer query into high and low parts and follow a recursive predecessor-search structure.
Wavelet Tree Range Quantiles
Navigate stable value partitions to answer subarray quantile and rank queries.