Binary Search Trees, in Depth

A BST is binary search, frozen into pointers

Binary search works because each comparison discards half the array. But the array's rigidity ruins updates. So take the decision pattern of binary search — "compare with the middle, go left or right" — and store it as a structure: the middle becomes the root, the two halves become subtrees, recursively. Searching walks the same path binary search would compute — but now inserting is just hanging one new node, no shifting.

Direct addressing — an array indexed by the key itself — gives O(1) everything. The price: an array as large as the key universe. Roll numbers like 229301234 would need an array of ~10⁹ slots to store 60 students. The BST spends memory on what you actually store, not on what you might store; hashing (Unit II, later) is the other answer. Trees additionally keep keys in order — ranges, nearest-key, sorted listing — which hashing never will.

Each node carries: key · left (pointer to left child) · right · p (pointer to parent — the upward link; p[root] = NIL). Every child is linked to its parent from both directions.

Read the fine print: the rule binds entire subtrees, not just children. In the tree alongside, 40 < 50 even though 40 is two levels down on 50's left. This global rule is exactly what makes every operation a single root-to-leaf walk — at each node, one comparison eliminates one whole subtree, just like binary search eliminates half the array.

Free bonus — inorder traversal (left subtree, node, right subtree) visits: 20, 30, 40, 50, 60, 70, 80 — sorted, automatically. A BST is a sorting of the keys, stored as geometry. This is also your instant correctness check for every exercise: if inorder isn't sorted, the tree is wrong.

walk from the root, remembering the parent y:
    if new key < current → go left
    else              → go right
when you step onto an EMPTY slot (NIL):
    place the new node there
    p[new] ← y            // child → parent link
    left[y] or right[y] ← new  // parent → child link

Two pointers set, in both directions — the new node is stitched in, never inserted "between" anything. No shifting, ever. Cost: the walk, O(h).

Keys arrive in this order: 50, 30, 70, 20, 40, 60, 80. At each step the amber nodes are the comparison path walked, the teal node is the newly linked child — watch its connector tick attach to the parent — and dotted boxes are empty slots (NIL): real places where a future key can land.

Tree-Search(x, k):
    if x = NIL or k = key[x]: return x
    if k < key[x]: return Tree-Search(left[x], k)
    else:          return Tree-Search(right[x], k)

Each comparison discards an entire subtree — never to be looked at again. Running time: O(h), one node per level.

Searching for an absent key doesn't fail randomly — it walks to exactly the empty slot where that key would be inserted. Search and insert are the same walk with different endings. (That's why insert was so easy.)

No children: just unlink it from its parent. Nothing else moves.

Splice it out: the parent adopts the only child directly (p[child] ← p[x]). The chain closes over the gap.

Can't unlink — two orphaned subtrees! Trick: overwrite x's key with its inorder successor (the smallest key in x's right subtree), then delete the successor — which never has a left child, so it's always Case 0 or 1.

Everything today cost O(h) — and we quietly hoped h ≈ log n. For random insertion order the height is provably O(log n) on average (the argument mirrors quicksort's average recursion depth). But real data is rarely random: auto-increment IDs, roll numbers, timestamps arrive sorted. Watch what our insert algorithm does to them →

Same structure, same code — a 50,000× slowdown, from input order alone.

Give every node a balance factor:

An AVL tree is a BST in which every node has bf ∈ {−1, 0, +1}. Perfectly equal heights aren't demanded — siblings may differ by one — just never more.

The payoff, guaranteed: this local rule forces h ≤ 1.44 log₂(n+2) — whatever order the keys arrive in. Sorted, reverse-sorted, adversarial: h stays O(log n), so search, insert, and delete stay O(log n). The hope becomes a contract.

The balanced tree: every bf is 0 — a valid AVL tree. The sorted-input chain: bf values −5, −4, −3, −2 (violations highlighted) — illegal at almost every node. An AVL tree would have refused to let this shape ever form.