Guaranteeing Performance

Binary Search Trees Symbol table: key-value pair abstraction.

n Insert a value with specified key.
n Search for value given key.
n Delete value with given key.

Binary search trees

Challenge 1: guarantee symbol table performance.
Randomized BSTs
n Make average case independent of input distribution.
n Extend average case guarantee to worst-case.
n Remove assumption on having a good hash function.
n Remove expensive (but infrequent) re-doubling operations.

Challenge 2: expand interface when keys are ordered.

Reference: Chapter 12, Algorithms in Java, 3rd Edition, Robert Sedgewick.
n Find the ith largest key.
n Range searching.

Princeton University • COS 226 • Algorithms and Data Structures • Spring 2004 • Kevin Wayne • http://www.Princeton.EDU/~cos226 2

Binary Search Tree Binary Search Tree in Java

Binary search tree: binary tree in symmetric order. A BST is a reference to a node.
51

A Node is comprised of four fields:

Binary tree is either: 14 72 n A key and a value.
n Empty. n A reference to the left and right subtree.
n A key-value pair and two binary trees. 33 53 97 root
smaller larger

25 43 64 84 99
51

private static class Node { left left

node
Symmetric order: Comparable key; key can be any
x Object value; Comparable object
n Keys in nodes. 14 68
Node left;
n No smaller than left subtree. Node right;
n No larger than right subtree. subtrees }
A B
helper class 12 54 79
smaller larger

3 4
 Tree Shape BST Skeleton

Tree shape.
public class SymbolTable {
n Many BSTs correspond to same input data. private Node root;
n Have different tree shapes.
private static class Node {
n Performance depends on shape. Comparable key;
Object value;
Node left, right;
25
Node(Comparable key, Object value) {
this.key = key;
51 14 72
this.value = value;
}
} helper inner class
14 43 97 helper functions
72
private static boolean less(Comparable k1, Comparable k2) { }
private static boolean equals(Comparable k1, Comparable k2) { }
33 53 97 33 53 84 99

public void put(Comparable key, Object value) { }

51 64
public Object get(Comparable key) { }
25 43 64 84 99
}
ST interface methods

5 6

BST Search BST Insert

Search for specified key and return corresponding value or null. Insert key-value pair.
n Code follows from BST definition. n Code follows from BST definition.
n Use helper function to search for key in subtree rooted at h. n Search, then insert.
n Simple (but tricky) recursive code.
n Duplicates allowed.

public Object get(Comparable key) {

return search(root, key); public void put(Comparable key, Object value) {
} root = insert(root, key, value);
}
private Object search(Node h, Comparable key) {
if (h == null) return null; not found private Node insert(Node h, Comparable key, Object value) {
if (equals(key, h.key)) return h.value; found if (h == null) return new Node(key, value);
if (less (key, h.key)) return search(h.left, key); if (less(key, h.key)) h.left = insert(h.left, key, value);
else return search(h.right, key); else h.right = insert(h.right, key, value);
} return h;
go left or right }

7 8
 BST Construction BST Analysis

Insert the following keys into BST: A S E R C H I N G X M P L Cost of search and insert BST.
n Proportional to depth of node.
n 1-1 correspondence between BST and quicksort partitioning.
n Height of node corresponds to number of function calls on stack
when node is partitioned.

Theorem. If keys are inserted in random order, then height of tree is

Q(log N), except with exponentially small probability. Thus, search and
insert take O(log N) time.

Problem. Worst-case search and insert are proportional to N.

n If nodes in order, tree degenerates to linked list.

9 10

Symbol Table: Implementations Cost Summary Symbol Table: Delete

To delete a node:
n Case 1 (zero children): just remove it.
Worst Case Average Case n Case 2 (one child): pass the child up.
Implementation Search Insert Delete Search Insert Delete n Case 3 (two children): find the next largest node using right-left*
Sorted array log N N N log N N/2 N/2 or left-right*, swap with next largest, remove as in Case 1 or 2.
Unsorted list N 1 1 N/2 1 1
Hashing N 1 N 1* 1* 1*
BST N N N log N log N ???

Case 1 Case 2 Case 3

BST: log N insert and search if keys arrive in random order.
Ahead: Can we make all ops log N if keys arrive in arbitrary order?
Problem: strategy clumsy, not symmetric.
Serious problem: trees not random (!!)

11 12
 Symbol Table: Implementations Cost Summary Right Rotate, Left Rotate

Fundamental operation to rearrange nodes in a tree.

n Maintains BST order.
Worst Case Average Case n Local transformations, change just 3 pointers.
Implementation Search Insert Delete Search Insert Delete
Sorted array log N N N log N N/2 N/2
Unsorted list N 1 1 N/2 1 1
Hashing N 1 N 1* 1* 1*
BST N N N log N log N sqrt(N) †
x
y

* assumes our hash function can generate random values for all keys
† if delete allowed, insert/search become sqrt(N) too y x
A y = left(x) C

Ahead: Can we achieve log N delete? B C x = right(y) A B

Ahead: Can we achieve log N worst-case?

13 14

Right Rotate, Left Rotate Recursive BST Root Insertion insert G

Fundamental operation to rearrange nodes in a tree. Root insertion: insert a node and make it the new root.
n Easier done than said. n Insert the node using standard BST.
n Use rotations to bring it up to the root.

Why bother?
private Node rotL(Node h) { n Faster if searches are for recently inserted keys.
Node x = h.right; n Basis for advanced algorithms.
h.right = x.left;
x.left = h; Node insertT(Node h, Comparable key, Object value) {
return x; if (h == null) return new Node(key, value);
} if (less(key, h.key)) {
h.left = insertT(h.left, key, value);
private Node rotR(Node h) { h = rotR(h);
Node x = h.left; }
h.left = x.right; else {
x.right = h; h.right = insertT(h.right, key, value);
return x; h = rotL(h);
} }
return h;
}
15 16
 BST Construction: Root Insertion Randomized BST

ASERCHINGXMPL Observation. If keys are inserted in random order then BST is

balanced with high probability.

Idea. When inserting a new node, make it the root (via root insertion)
with probability 1/(N+1) and do it recursively.

private Node insert(Node h, Comparable key, Object value) {

if (h == null) return new Node(key, value);
if (Math.random()*(h.N+1) < 1) return insertT(h, key, value);
if (less(key, h.key)) h.left = insert(h.left, key, value);
else h.right = insert(h.right, key, value);
h.N++;
return h;
}

Fact. Tree shape distribution is identical to tree shape of inserting

keys in random order.
n No assumptions made on the input distribution!
17 18

Randomized BST Example Randomized BST

Insert keys in order. Always "looks like" random binary tree.

n Tree shape still random.

n Implementation: maintain subtree size in each node.

n Supports all symbol table ops.
n log N average case.
n Exponentially small chance of bad balance.

19 20
 Randomized BST: Delete Symbol Table: Implementations Cost Summary

Join. Merge two disjoint symbol tables A (of size M) and B (of size N),
assuming all keys in A are less than all keys in B. Worst Case Average Case
Use A as root with probability M / (M + N), and recursively join
Implementation Search Insert Delete Search Insert Delete
n

right subtree of A with B

Sorted array log N N N log N N/2 N/2
n Use B as root with probability N / (M + N), and recursively join left
subtree of B with A Unsorted list N 1 1 N/2 1 1
Hashing N 1 N 1* 1* 1*
Delete. Given a key k, delete and return a node with key k. BST N N N log N log N sqrt(N) †

n Delete the node. Randomized BST log N ‡ log N ‡ log N ‡ log N log N log N
n Join two broken subtrees as above.
* assumes our hash function can generate random values for all keys
Theorem. Tree still random after delete. † if delete allowed, insert/search become sqrt(N)
‡ assumes system can generate random numbers

Randomized BST: guaranteed log N performance!

Next time: Can we achieve deterministic guarantee?

21 22

BST: Other Operations Randomized BST: Other Operations

Sort. Traverse tree in ascending order. Ceiling. Given key k, return smallest element that is at least as big as k.
n Inorder traversal.
n Same comparisons as quicksort, but pay space for extra links. Best-fit bin packing heuristic. Insert the item in the bin with the least
remaining space among those that can store the item.

Range search. Find all items whose keys are between k1 and k2.

Theorem. Best-fit decreasing is guaranteed use no more than 11B/9 + 1

Find kth largest. Generalized PQ that finds kth smallest.
bins, where B is the best possible.
Special case: find min, find max.
– within 22% of best possible.
n

M
n Add subtree size to each node. 10 – original proof of this result was over 70 pages of analysis!
n Takes time proportional to height of tree.
E T
4 5
private class Node {
Comparable key; B H P W
Object value; 1 2 1 3
Node left, right;
int N; F V Y
} subtree size 1 1 1
23 24
 Symbol Table: Implementations Cost Summary

Worst Case Asymptotic Cost

Implementation Search Insert Delete Find kth Sort Join Ceil

Sorted array log N N N log N N N log N
Unsorted list N 1 1 N N log N N N
Hashing 1* 1* 1* N N log N N N
BST N N N N N N N
Randomized BST log N ‡ log N ‡ log N ‡ log N ‡ log N ‡ log N ‡ log N ‡

* assumes our hash function can generate random values for all keys
‡ assumes system can generate random numbers

makes no assumption on input distribution

Randomized BST: O(log N) average case for ALL ops!

Next time: Can we achieve deterministic guarantee?

25