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.