1. CSE 326: Data Structures Lecture #7 Binary Search Trees Alon Halevy Spring Quarter 2001

2. Binary Trees Many algorithms are efficient and easy to program for the special case of binary trees Binary tree is –a root –left subtree (maybe empty) –right subtree (maybe empty) A B DE C F HG JI

3. Representation A A B DE C F BCDEF Data right pointer left pointer

4. Properties of Binary Trees Max # of leafs in a tree of height h = Max # of nodes in a tree of height h = A B DE C FG

5. Dictionary & Search ADTs Operations –create –destroy –insert –find –delete Dictionary: Stores values associated with user-specified keys –keys may be any (homogenous) comparable type –values may be any (homogenous) type –implementation: data field is a struct with two parts Search ADT: keys = values kim chi –spicy cabbage kreplach –tasty stuffed dough kiwi –Australian fruit insert find(kreplach) kohlrabi - upscale tuber kreplach - tasty stuffed dough

6. Naïve Implementations unsorted array sorted array linked list insertfind + O(n)O(n)find + O(1) findO(n)O(log n)O(n) deletefind + O(1) (if no shrink) O(n)find + O(1) Goal: fast find like sorted array, dynamic inserts/deletes like linked list

7. Binary Search Tree Dictionary Data Structure 4 121062 115 8 14 13 79 Search tree property –all keys in left subtree smaller than root’s key –all keys in right subtree larger than root’s key –result: easy to find any given key inserts/deletes by changing links

8. Example and Counter-Example 3 1171 84 5 4 1062 185 8 BINARY SEARCH TREE NOT A BINARY SEARCH TREE 7

9. In Order Listing visit left subtree visit node visit right subtree 2092 155 10 307 17 In order listing: 2  5  7  9  10  15  17  20  30

10. Finding a Node Node *& find(Comparable x, Node * root) { if (root == NULL) return root; else if (x key) return find(x, root->left); else if (x > root->key) return find(x, root->right); else return root; } 2092 155 10 307 17 runtime:

11. Insert Concept: proceed down tree as in Find; if new key not found, then insert a new node at last spot traversed void insert(Comparable x, Node * root) { assert ( root != NULL ); if (x key){ if (root->left == NULL) root->left = new Node(x); else insert( x, root->left ); } else if (x > root->key){ if (root->right == NULL) root->right = new Node(x); else insert( x, root->right ); } }

12. BuildTree for BSTs Suppose a 1, a 2, …, a n are inserted into an initially empty BST: 1.a 1, a 2, …, a n are in increasing order 2.a 1, a 2, …, a n are in decreasing order 3.a 1 is the median of all, a 2 is the median of elements less than a 1, a 3 is the median of elements greater than a 1, etc. 4.data is randomly ordered

13. Examples of Building from Scratch 1, 2, 3, 4, 5, 6, 7, 8, 9 5, 3, 7, 2, 4, 6, 8, 1, 9

14. Analysis of BuildTree Worst case is O(n 2 ) 1 + 2 + 3 + … + n = O(n 2 ) Average case assuming all orderings equally likely is O(n log n) –not averaging over all binary trees, rather averaging over all input sequences (inserts) –equivalently: average depth of a node is log n –proof: see Introduction to Algorithms, Cormen, Leiserson, & Rivest

15. Bonus: FindMin/FindMax Find minimum Find maximum 2092 155 10 307 17

16. Deletion 2092 155 10 307 17 Why might deletion be harder than insertion?

17. Deletion - Leaf Case 2092 155 10 307 17 Delete(17)

18. Deletion - One Child Case 2092 155 10 307 Delete(15)

19. Deletion - Two Child Case 3092 205 10 7 Delete(5) replace node with value guaranteed to be between the left and right subtrees: the successor Could we have used the predecessor instead?

20. Finding the Successor Find the next larger node in this node’s subtree. –not next larger in entire tree Node * succ(Node * root) { if (root->right == NULL) return NULL; else return min(root->right); } 2092 155 10 307 17 How many children can the successor of a node have?

21. Predecessor Find the next smaller node in this node’s subtree. Node * pred(Node * root) { if (root->left == NULL) return NULL; else return max(root->left); } 2092 155 10 307 17

22. Deletion - Two Child Case 3092 205 10 7 Delete(5) always easy to delete the successor – always has either 0 or 1 children!

23. Delete Code void delete(Comparable x, Node *& p) { Node * q; if (p != NULL) { if (p->key right); else if (p->key > x) delete(x, p->left); else { /* p->key == x */ if (p->left == NULL) p = p->right; else if (p->right == NULL) p = p->left; else { q = successor(p); p->key = q->key; delete(q->key, p->right); }

24. Lazy Deletion Instead of physically deleting nodes, just mark them as deleted +simpler +physical deletions done in batches +some adds just flip deleted flag –extra memory for deleted flag –many lazy deletions slow finds –some operations may have to be modified (e.g., min and max) 2092 155 10 307 17

25. Lazy Deletion 2092 155 10 307 17 Delete(17) Delete(15) Delete(5) Find(9) Find(16) Insert(5) Find(17)

26. Dictionary Implementations BST’s looking good for shallow trees, i.e. the depth D is small (log n), otherwise as bad as a linked list! unsorted array sorted array linked list BST insertfind + O(n)O(n)find + O(1)O(Depth) findO(n)O(log n)O(n)O(Depth) deletefind + O(1)O(n)find + O(1)O(Depth)

27. Beauty is Only  (log n) Deep Binary Search Trees are fast if they’re shallow: –e.g.: perfectly complete –e.g.: perfectly complete except the “fringe” (leafs) –any other good cases? What matters here? Problems occur when one branch is much longer than the other!