Data Structures

Data structures organize data for efficient access and modification. Explore how linked lists, stacks, queues, hash tables, trees, and heaps store data and support their core operations — every insert, delete, and lookup animated step by step.

71 results

Linked Lists

(6)

Circular Linked List

Maintains a singly linked cycle where the tail always links back to the head.

Intermediatelinked listpointers

Doubly Linked List

Demonstrates a doubly linked list's core operations: insert at head/tail and delete, with two-way prev/next pointers.

Beginnerlinked listdoubly linked

Floyd's Cycle Detection

Detects a loop in a linked list with two pointers moving at different speeds, then finds the cycle's entry node.

Intermediatelinked listtwo pointers

Merge Two Sorted Lists

Merges two sorted linked lists into one sorted list by repeatedly splicing the smaller head node.

Beginnerlinked listtwo pointers

Reverse a Linked List

Reverses a singly linked list in place by flipping each node's next pointer using three pointers.

Beginnerlinked listpointers

Singly Linked List Operations

Performs front/back insertion, search, and deletion with explicit pointer rewiring.

Beginnerlinked listpointers

Stacks & Queues

(9)

Balanced Parentheses

Uses a stack to verify that every opening bracket has a correctly ordered matching closing bracket.

Beginnerstackmatching

Circular Queue (Ring Buffer)

A fixed-size queue whose front and rear indices wrap around with modulo arithmetic, reusing freed slots.

Intermediatequeuering buffer

Deque Operations

Pushes and pops at both ends while maintaining front/back links.

Beginnerdequedouble ended queue

Min-Stack (O(1) minimum)

A stack that also returns its minimum in O(1) by caching a running minimum with every pushed value.

Intermediatestackdesign

Monotonic Stack

Finds every next-greater element by maintaining a decreasing stack of unresolved indices.

Intermediatestacknext greater element

Priority Queue

Uses a stable binary min-heap to enqueue and serve items by priority.

Intermediatepriority queuebinary heap

Queue (FIFO)

A first-in-first-out structure supporting enqueue at the rear and dequeue from the front in O(1).

BeginnerqueueFIFO

Queue Using Two Stacks

Implements FIFO behavior by transferring items between input and output stacks only when needed.

Intermediatequeuetwo stacks

Stack (LIFO)

A last-in-first-out structure supporting push, pop, and peek — each in O(1).

BeginnerstackLIFO

Hashing

(9)

Bloom Filter

Uses several hash-derived bits for space-efficient membership checks with possible false positives.

Intermediateprobabilisticbitset

Cuckoo Hashing

Stores every key in one of two hash locations, evicting occupants and resizing on a cycle.

Advancedhashingtwo tables

Hash Table — Double Hashing

Uses a second hash function as the step size, so different keys sharing a home slot follow completely different probe paths — no clustering.

Advancedhash tableopen addressing

Hash Table — Linear Probing

Resolves collisions by scanning forward one slot at a time until a free cell is found — simple and cache-friendly, but prone to clustering.

Intermediatehash tableopen addressing

Hash Table — Quadratic Probing

Resolves collisions with quadratically growing jumps (+1, +4, +9, …), breaking up the contiguous runs that plague linear probing.

Intermediatehash tableopen addressing

Hash Table — Separate Chaining

Resolves hash collisions by storing colliding keys in a per-bucket linked list.

Intermediatehash tablechaining

LFU Cache

Evicts the least frequently used key, breaking equal-frequency ties by recency.

Advancedhashingcache

LRU Cache

Combines lookup with recency order and evicts the least recently used key.

Intermediatehashingcache

Robin Hood Hashing

Equalizes probe lengths by letting farther-travelled keys displace richer residents.

Advancedhashingopen addressing

Trees & Heaps

(47)

2-3 Tree

Inserts into one/two-key nodes and exposes every temporary three-key overflow, split, and promotion.

Advancedbalanced multiway treesplit

AA Tree

Maintain a level-based balanced search tree using only right and left rotations.

Advancedbalanced BSTskew

AVL Tree (Self-Balancing BST)

A height-balanced binary search tree that rotates after inserts to keep every balance factor in {−1, 0, +1}.

Advancedtreeself-balancing

B-Tree

A balanced multiway search tree where nodes hold many keys and split when full, keeping all leaves at the same depth.

Advancedtreebalanced

B-Tree Indexing Engine

Traces multiway node splits during insertion.

Advancedscientific computingnative TypeScript

Binary Lifting LCA

Precompute power-of-two ancestors and answer LCA queries with logarithmic jumps.

AdvancedLCAbinary lifting

Binary Search Tree

An ordered tree where left < node < right, giving O(h) search, insertion, and deletion.

Intermediatetreeordered

Binary Tree Traversals

Visits every node in in-order, pre-order, post-order, or level-order — the four canonical traversals.

BeginnertreeDFS

Cartesian Tree

Build a min-Cartesian tree whose inorder traversal is the original sequence.

Intermediatemonotonic stackrange minimum

Centroid Decomposition

Recursively remove a balanced centroid from each remaining component.

Advancedcentroiddivide and conquer

Decision Tree Induction

Scores split thresholds using weighted Gini impurity.

Advancedscientific computingnative TypeScript

Euler Tour LCA

Reduce lowest-common-ancestor queries to range minima over an Euler tour.

AdvancedLCAEuler tour

Expression Tree

Converts infix to postfix, builds the exact operator tree, and evaluates it bottom-up.

Intermediateexpressionshunting yard

Fenwick Tree (Binary Indexed Tree)

A compact array that answers prefix-sum queries and point updates in O(log n) using the low-bit trick i & −i.

AdvancedBITprefix sum

Finger Tree

Provides amortized constant-time access at both sequence ends with cached measures.

Advancedfunctional sequencemonoid

Heavy-Light Decomposition

Split root-to-leaf paths into heavy chains so any path uses logarithmically many segments.

Advancedpath queryheavy edge

Implicit Treap (Rope)

Represents sequence positions by subtree sizes for split, merge, and reversal.

Advancedtreaprope

Interval Tree

Stores subtree maximum endpoints and uses them to prune overlap searches safely.

Advancedintervalsaugmented BST

KD Tree

Alternates x/y splits during insertion and performs nearest-neighbor search with legal branch pruning.

Advancedspatial treenearest neighbor

Lazy Segment Tree Range Update

Defers range additions while preserving sums.

Advancedscientific computingnative TypeScript

Level-Order Traversal (BFS)

Visits a binary tree breadth-first, level by level, using a FIFO queue to process nodes in order.

Beginnertreebfs

Link-Cut Tree

Maintains dynamic forest paths through preferred-path splay trees.

Advanceddynamic treessplay tree

Max-Heap

Builds a complete max-heap with visible swaps and extracts requested maxima one at a time.

Intermediateheapcomplete tree

Merkle Tree

Hash leaves and pairwise child digests until one authenticated root remains.

Advancedhash treeintegrity

Min-Heap (Binary Heap)

Builds a binary min-heap via sift-up insertions and removes the minimum with sift-down, all in an array.

Intermediateheappriority queue

Morris Traversal

Traverse a binary tree inorder using temporary predecessor threads.

Advancedinorderthreading

Octree

Recursively divide 3D space into eight octants.

Advancedspatial index3D

Order-Statistic Tree

Augment a search tree with subtree sizes to answer rank and selection queries.

Advancedaugmented BSTrank

Persistent Segment Tree

Path-copies updates so every historical range-query version remains accessible.

Advancedpersistencerange query

Quadtree

Recursively divide 2D space into four quadrants and prune range searches.

Advancedspatial index2D

R-Tree

Group spatial rectangles by bounding-box enlargement and split overflowing nodes.

Advancedspatial indexbounding rectangle

Radix Tree

Compress unary trie paths into substring-labelled edges.

Advancedcompressed trieprefix

Red-Black Tree

A self-balancing BST that uses node colors and 5 invariants to guarantee O(log n) operations with few rotations.

Advancedtreeself-balancing

Scapegoat Tree

Restores weight balance by rebuilding the first excessively deep ancestor.

Advancedbalanced BSTrebuild

Segment Tree (Range Queries)

Answers range-sum queries and point updates in O(log n) by storing partial sums over a binary tree of index ranges.

Advancedtreerange query

Segment Tree with Lazy Propagation

Defers range updates in lazy tags while preserving logarithmic queries.

Advancedrange updatelazy propagation

Skip List

Maintains probabilistic express lanes over an ordered linked structure.

Advancedordered setprobability

Splay Tree

Moves every inserted or accessed node to the root through explicit zig and double rotations.

Advancedself-adjusting treezig

Splay Tree Rotations

Traces zig and double rotations toward the root.

Advancedscientific computingnative TypeScript

Suffix Trie

Insert every text suffix so substring queries become trie walks.

Advancedsuffixsubstring

Threaded Binary Tree

Reuses null links as predecessor/successor threads and traverses in-order without recursion or a stack.

Advancedthreaded treeinorder successor

Treap

Preserves BST order by key and min-heap order by priority using rotations.

AdvancedBSTheap priority

Treap Dual Invariant

Maintains BST order and heap priorities.

Advancedscientific computingnative TypeScript

Tree Diameter

Find a longest tree path using two breadth-first sweeps.

Intermediatelongest pathtwo BFS

Trie (Prefix Tree)

Stores a set of strings in a prefix tree, sharing common prefixes; supports fast insert and lookup by walking edges.

Intermediatetrieprefix tree

van Emde Boas Tree

Recursively split a bounded integer universe to support successor queries.

Advancedinteger setsuccessor

Wavelet Tree

Recursively partitions an alphabet to answer rank, select, and range-kth queries.

Advancedrankselect