CSE 326: Data Structures Lecture #8 Binary Search Trees

Transcription

1 CSE 6: Data Structures Lecture #8 Binary Search Trees Alon Halevy Spring Quarter Binary Trees Many algorithms are efficient and easy to program for the special case of binary trees B A C Binary tree is a root D E F left subtree (maybe empty) right subtree (maybe empty) G H I J

2 Representation A Data B C left pointer right pointer B A C D E F D E F Properties of Binary Trees Max # of leafs in a tree of height h = B A C Max # of nodes in a tree of height h = D E F G

3 Dictionary & Search ADTs Operations create destroy insert find delete insert kohlrabi - upscale tuber kreplach - tasty stuffed dough find(kreplach) kim chi spicy cabbage kreplach tasty stuffed dough kiwi Australian fruit 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 Naïve Implementations unsorted array sorted array linked list insert find + O(n) O(n) find + O() find O(n) O(log n) O(n) delete find + O() (if no shrink) O(n) find + O() Goal: fast find like sorted array, dynamic inserts/deletes like linked list

4 Binary Search Tree Dictionary Data Structure Search tree property all keys in left subtree smaller than root s key all keys in right subtree larger than root s key 8 result: easy to find any given key 6 inserts/deletes by changing links Example and Counter-Example BINARY SEARCH TREE NOT A BINARY SEARCH TREE

5 In Order Listing visit left subtree visit node visit right subtree 7 7 In order listing: 7 7 Finding a Node 7 7 runtime: Node *& find(comparable x, Node * root) { } if (root == NULL) return root; else if (x < root->key) return find(x, root->left); else if (x > root->key) else return find(x, root->right); return root;

6 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 < root->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 ); } } BuildTree for BSTs Suppose a, a,, a n are inserted into an initially empty BST:. a, a,, a n are in increasing order. a, a,, a n are in decreasing order. a is the median of all, a is the median of elements less than a, a is the median of elements greater than a, etc. 4. data is randomly ordered

7 Examples of Building from Scratch,,, 4,, 6, 7, 8,,, 7,, 4, 6, 8,, Analysis of BuildTree Worst case is O(n ) n = O(n ) 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

8 Bonus: FindMin/FindMax Find minimum Find maximum 7 7 Deletion 7 7 Why might deletion be harder than insertion?

9 Deletion - Leaf Case Delete(7) 7 7 Deletion - One Child Case Delete() 7

10 Deletion - Two Child Case Delete() 7 replace node with value guaranteed to be between the left and right subtrees: the successor Could we have used the predecessor instead? 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); } 7 7 How many children can the successor of a node have?

11 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); 7 7 Deletion - Two Child Case Delete() 7 always easy to delete the successor always has either or children!

12 Delete Code void delete(comparable x, Node *& p) { Node * q; if (p!= NULL) { } } if (p->key < x) delete(x, p->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); 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) 7 7

13 Delete(7) Delete() Delete() Lazy Deletion Find() Find(6) Insert() Find(7) 7 7 Dictionary Implementations unsorted array sorted array linked list BST insert find + O(n) O(n) find + O() O(Depth) find O(n) O(log n) O(n) O(Depth) delete find + O() O(n) find + O() O(Depth) BST s looking good for shallow trees, i.e. the depth D is small (log n), otherwise as bad as a linked list!

14 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! Balance t Balance height(left subtree) - height(right subtree) zero everywhere perfectly balanced small everywhere balanced enough 7 Balance between - and everywhere maximum height of.44 log n

15 AVL Tree Dictionary Data Structure Binary search tree properties binary tree property search tree property Balance property balance of every node is: - b result: depth is Θ(log n) An AVL Tree data height children 7

16 Not AVL Trees - = - 7 (-)- = - Staying Balanced Good case: inserting small, tall and middle. Insert(middle) Insert(small) Insert(tall) S M T

17 Bad Case # Insert(small) Insert(middle) Insert(tall) S M T Single Rotation S M T M S T Basic operation used in AVL trees: A right child could legally have its parent as its left child.

18 General Case: Insert Unbalances a h + a h + h h - b X h + h - b X h- h - h h - Z Y Y Z General Single Rotation a h + b h + h + h - b h h - Y X h Z h - Y a h X h - Z Height of left subtree same as it was before insert! Height of all ancestors unchanged We can stop here!

19 Bad Case # Insert(small) Insert(tall) Insert(middle) Will a single rotation fix this? S M T Double Rotation S M T S M T M S T

20 h - W h + General Double Rotation a b c X h h + Z Y h - h h - b a X Y W c h + h Z h - h -? h -? Initially: insert into either X or Y unbalances tree (root height goes to h+) Zig zag to pull up c restores root height to h+, left subtree height to h Find spot for value Hang new node Insert Algorithm Search back up looking for imbalance If there is an imbalance: case #: Perform single rotation and exit case #: Perform double rotation and exit

21 Easy Insert Insert() 7 Hard Insert (Bad Case #) Insert() 7

22 Single Rotation 7 7 Hard Insert (Bad Case #) Insert(8) 7

23 Single Rotation (oops!) Double Rotation (Step #) Look familiar? 8

24 Double Rotation (Step #) AVL Algorithm Revisited Recursive. Search downward for spot. Insert node. Unwind stack, correcting heights a. If imbalance #, single rotate b. If imbalance #, double rotate Iterative. Search downward for spot, stacking parent nodes. Insert node. Unwind stack, correcting heights a. If imbalance #, single rotate and exit b. If imbalance #, double rotate and exit

25 Single Rotation Code void RotateRight(Node *& root) { Node * temp = root->right; } root->right = temp->left; temp->left = root; root->height = max(root->right->height, root->left->height) + ; temp->height = max(temp->right->height, root = temp; X temp->left->height) + ; root Y temp Z Double Rotation Code void DoubleRotateRight(Node *& root) { RotateLeft(root->right); } RotateRight(root); a First Rotation a b c Z c Z Y b Y X W X W

26 Double Rotation Completed First Rotation a c a Second Rotation c b Z Y b Y X X Z W W