Comparative Analysis of Advanced Tree Structures

Across Lectures 7–14 you built, by hand, the BST, AVL tree, Red-Black tree, Splay tree, B-tree/B+-tree/B*-tree, Trie, Digital Search Tree, Segment tree, Interval tree, and Suffix tree. Each lecture asked "how does this one work?" None of them asked the question an engineer actually faces first: given this workload, which one do I reach for?

Picking wrong is expensive, not just inelegant. A database index built as a plain binary search tree instead of a B+-tree can turn a 3-disk-read lookup into a 20-disk-read lookup — on every single query. A router forwarding table built as a sorted array instead of a trie turns an O(1)-ish prefix match into a binary search that still doesn't naturally support "longest prefix." Today builds the decision framework so that choice is deliberate, not accidental.

Is worst-case height bounded at all? By how tight a constant? Unbalanced BSTs have none; AVL and RB guarantee O(log n) with different constants; Splay guarantees it only amortized, not per operation.

Binary (2 children) vs. multiway (B-trees: dozens to hundreds of children per node). Higher branching factor means shallower trees — the whole reason B-trees exist for disk-resident data.

Ordered scalar keys (BST family, B-tree family) vs. string/bit keys decomposed character-by-character (Trie, DST, Suffix tree) vs. ranges/intervals (Segment tree, Interval tree).

Rotations (AVL, RB, B-tree splits), pure recoloring (RB, cheaper than a rotation), or no explicit rebalancing at all but restructuring on every access (Splay).

Designed for in-RAM pointer-chasing (BST family) vs. designed to minimize block/page reads from secondary storage (B-tree family) — a difference that dominates real-world performance far more than the Big-O alone suggests.

Every comparison in this lecture is really just: where does this structure sit on these five axes, and what does that cost or buy you? Keep this list open — we'll refer back to it constantly.

• AVL's tight height costs more rotations per insert/delete than Red-Black — verified numerically in this lecture's own head-to-head (3 rebalancing events vs. 2, for the same 6 keys).
• B-trees' shallow height costs wasted space in partially-full nodes (a node can legally be as little as half full) and more complex split/merge logic than a binary rotation.
• Tries' O(L) search costs Θ(N·|Σ|) space in the worst case — fixed by compression (Lecture 13), which then costs implementation complexity.
• Suffix trees' O(p) pattern search costs a genuinely intricate O(m) build (Ukkonen's algorithm) — which is exactly why suffix arrays often win in production despite being conceptually simpler, not more powerful.
• Splay trees' automatic adaptation costs any worst-case per-operation guarantee at all — one unlucky access can legitimately cost O(n).

Every structure in this course is a different answer to the same question — "where should the cost go?" — and the right answer always depends on which operation your workload actually calls the most, not on which structure looks the most sophisticated on a slide.

C++'s std::map/std::set and Java's TreeMap/TreeSet are implemented as red-black trees in their standard library implementations. The Linux kernel uses red-black trees for the CFS process scheduler's run-queue and for tracking virtual memory areas.

The default on-disk index structure for most relational databases (e.g. InnoDB's clustered indexes in MySQL) and many filesystems — high branching factor is chosen specifically to match the disk block size, minimizing seeks.

IP routers use trie-like structures (compressed/PATRICIA tries) for longest-prefix-match forwarding lookups; search engines use tries for autocomplete and prefix-based term indices.

Well-suited to caches and any workload with strong temporal locality — recently or frequently accessed keys migrate toward the root and stay cheap, with no separate cache-eviction bookkeeping needed.

Computational-geometry engines, scheduling systems ("which meetings overlap this time slot?"), and graphics/collision-detection pipelines that need fast range or overlap queries.

Bioinformatics tools for genome alignment and repeat-finding; full-text search engines and version-control diff tools that need fast substring queries over large fixed texts.