1. 1 CompSci 105 SS 2006 Principles of Computer Science Lecture 17: Heaps cont.

2. 2 An Aside: Iterators Quite often we want to get data in a certain order We want the data to come one at a time at our leisure We do not care how it gets the data, as long as it is in the order we expect

3. 3 An Aside: Iterators The Iterator interface abstracts this concept for us Interface: Iterator boolean hasNext() Object next() void remove() (optional)

4. 4 An Aside: Iterators Writing an Iterator is simple Mostly return these from various methods e.g. BST public Iterator getPostOrderTraversal(){...} -or- public static Iterator getPreOrderTraversal(BinaryTree b){...}

5. 5 An Aside: Iterators How the Iterator arrives at the next node is completely up to the writer The user has no idea Turns any data structure into a sorted list

6. 6 Heap Implementation U J G Q MB As a tree

7. 7 Binary Trees in Arrays? M Q UO G JB 0 1 2 3 456 As a tree

8. 8 Binary Trees in Arrays! M Q UO G JB 0 1 2 3 456 0M 1G 2Q 3B 4J 5O 6U As a tree As an array

9. 9 Other Implementations of Trees Multiple array implementation –Easy –left and right child references are indices to array –Does not require following object references

10. 10 Array implementation 0U12 1Q34 2J5 3B 4M 5G 6 U J G Q MB

11. 11 Other Implementations of Trees Single array implementation –most memory and speed efficient –Does not require references (i.e. compatible with almost all languages) –tree is stored in level order in array –“Missing” children are null –Use formulae to find children or parent...

12. 12 Array implementation Given node at index ‘i’ in the array... parentIndex = (i-1)/2; rightChild = 2*i+1; leftChild= 2*i+2; 0U 1Q 2J 3B 4M 5G 6null U J G Q MB

13. 13 Heap Delete Operation Retrieves and then deletes a Heap’s root item –Return the item in the root –Produce a semi-heap –Transform the semi-heap into a Heap

14. 14 Return the item in the root Produce a semi-heap Transform the semi-heap into a Heap

15. 15 Return the item in the root Produce a semi-heap Transform the semi-heap into a Heap

16. 16 Return the item in the root Produce a semi-heap Transform the semi-heap into a Heap –Allows the item in the root to trickle down to its right place –Compare the search key in the root with that of its children's –Swap the item in the root with that of the larger child

17. 17 Transform the semi-heap into a Heap –Allows the item in the root to trickle down to its right place –Compare the search key in the root with that of its children's –Swap the item in the root with that of the larger child

18. 18 Heap Insert Operation Insert a new item into a Heap –New item is inserted at the bottom of the tree –Then it trickled up to its proper place Compare the search key in current node with that of its parent Swap the current node with its parent, if the current node has greater value The efficiency of a Heap Insert and Heap Delete is O(log n)

19. 19 Heap Insert Operation

20. 20 Heap insert heap[size] = newItem; child=size; parent=(size-1)/2; while ( parent>=0 && heap[child]>heap[parent] ) { temp = heap[parent] ; heap[parent] = heap[child] ; heap[child] = temp ; child=parent; parent=(parent-1)/2; } 0U 1Q 2J 3B 4M 5G 6 size = 6 newItem = K

21. 21 Heaps remain complete and efficient BST’s may not BUT – Heaps have restrictions on use How to make BST more balanced without restricting its use? Back to Trees

22. 22 Balanced Trees Obviously need to sacrifice some efficiency to keep balanced But if can guarantee tree is balanced, make search very efficient Two methods: –Splay Trees –AVL trees

23. 23 Tree Rotations A rotation replaces the root of a subtree with one of its children. Rotation is an important operation for maintaining the balance of a Binary Search Tree.

24. 24 Rotations Note that rotation operation can make certain children “parentless” These children/subtrees must be inserted into tree at appropriate locations

25. 25 TreeNode rotateRight(TreeNode p) { if (p == null) return null; else if (p.getLeft() == null) return p; else { TreeNode newRoot = p.getLeft(); p.setLeft(newRoot.getRight()); newRoot.setRight(p); return newRoot;} } Question: Why can X’s child, B, always be made P’s left child??

26. 26 Left Rotation??? Homework exercise...

27. 27 Splay Trees A Splay Tree is a BST that rearranges its nodes during the access of nodes Splay – whenever a node is added, removed or retrieved, move the referenced node to become the new root of the Tree –In the case of removal, splay the tree around the parent node The average depth of those nodes to the root is halved, more close to the top of the tree and more efficiently accessed Can guarantee the O(log 2 n) performance

28. 28 Splaying a node Case 0: If x is the root, we are done. Case 1: If x is a left/right child of the root, rotate the tree to the right/left about the root. x becomes the root and we are done. Case 2a: If x is the left child of its parent p, and p is the left child of its grandparent g, rotate first right about g, followed by a right rotation about p. This is called a double-right rotation. If x is the right child of a right child perform a double-left rotation. After the double rotation, continue splay at x in the new tree. Case 2b: If x is the right child of its parent p, and p is the left child of its grandparent g, we rotate first left around p and then right around g. This is called a left- right double rotation. If x is the left child of a right child perform a right-left double rotation. After the double rotation, continue splay at x in the new tree.

29. 29 Splaying a node Case 1: The parent of x is root =>perform a single rotation

30. 30 Splaying a node Case 2a: The parent of x is not the root and it is the left (right) child of a left(right) child => perform a double-right (double-left) rotation

31. 31 Splaying a node Case 2b: The parent of x is not the root and it is the left (right) child of a right (left) child => perform a right-left (left-right) double rotation

32. 32 Splaying a node Example: Splay the tree around node 5

33. 33 Intuitive method... Always rotate node toward the root.

34. 34 Efficiency?? What is the efficiency of splaying a node to the root? How often will this happen?

35. 35 AVL Trees The AVL tree is named after its two inventors, G.M. Adelson-Velsky and E.M. Landis Keeps a BST tree mostly balanced so that all operations remain O(log 2 n)

36. 36 AVL Trees An AVL Tree is a Binary Search Tree that the heights of the left and right subtrees of any node differ by no more than 1 : | HeightLeft – HeightRight | ≤1 Operations on an AVL tree is almost as efficiently as a minimum-height Binary Search Tree After each insert or delete, check whether the tree is still an AVL Tree; if not, restore the property by tree rotations

37. 37 Efficiency?? What is the efficiency of checking the height of the left and right subtree of the root of a tree?? How often will this happen?

38. 38

39. 39 Rotations to obtain AVL property Case 0: No rotation needed Case 1: Single rotation to the Left (Right) to obtain a balanced shape Case 2: Double Right-Left (Left-Right) rotation to obtain a balanced shape

40. 40 Rotations to obtain AVL property Case 0: No rotation needed

41. 41 Rotations to obtain AVL property Case 1: Single rotation to the Left (Right) to obtain a balanced shape

42. 42 Rotations to obtain AVL property Case 2: Double Right-Left (Left-Right) rotation to obtain a balanced shape

43. 43 Comparison Splay Trees Slowest Average=worst=best Commonly accessed nodes near root All operations need rotation AVL Trees Trade off between two Average=worst=best Nodes randomly distributed Only some add/delete need rotation BST Trees Fastest if balanced, otherwise slowest Average!=worst!=best Nodes randomly distributed No rotation