1. Data Structures Haim Kaplan and Uri Zwick November 2012 Lecture 3 Dynamic Sets / Dictionaries Binary Search Trees

2. 2 Dictionaries/Dynamic sets Maintain a set of items. Each item has key and info fields. Keys belong to a totally ordered universe, and can be compared with each other Support the following operations: Insert, Delete, Search, Min, Max, … Extremely useful data structure!

3. Abstract Data Type: Dictionaries Dic-Item(k,i) – Create a dictionary item containing key k and info i, Key(I), Info(I) – The key and info contained in Dic-Item I. Dictionary() – Create an empty dictionary Insert(D,I) – Insert I into D Delete(D,I) – Delete I from D (assuming I is in D) Search(D,k) – Find a dic-item with key k in D, if any. Min(D) – Return the dic-item with the minimum key in D. Max(D) – Return the dic-item with the maximum key in D. Successor(D,I) – Return the successor of I in D. Predecessor(D,I) – Return the predecessor of I in D. Assume that dic-items have distinct keys

4. 4 Implementing dictionaries using lists Store the dic-items in a list (in no particular order). Insert a new dic-item to an arbitrary position of the list, e.g., the first or last position. Delete a dic-item by either using a supplied pointer to it, or by first locating it in the list. Search, and other operations, are implemented by scanning the list.

5. 5 Implementing dictionaries using doubly linked lists (ver. 1) Store the dic-items in a list, in no particular order. Insert a new dic-item to an arbitrary position of the list, e.g., the first or last position. Delete a dic-item using a supplied pointer to it. Search, and other operations, are implemented by scanning the list. Insert, Delete – O(1) time Other operations – O(n) time

6. 6 Implementing dictionaries using doubly linked lists (ver. 2) Store the dic-items in a list, in increasing order of keys. Insert a new dic-item to the appropriate position Delete a dic-item by using a supplied pointer to it. Search is implemented by scanning the list, stopping when the key of the current item is larger than the key sought. Insert,Search – O(n) time (or O(n/2) “on average”) Delete – O(1) time Min, Max, Successor, Predecessor – O(1) time

7. 7 Implementing dictionaries using (circular) arrays Store the dic-items in a list, in increasing order of keys. Insert a new dic-item to the appropriate position Delete a dic-item by using a supplied pointer to it. Search implemented using binary search. Insert, Delete – O(n) time (or O(n/2) ) Min, Max, Successor, Predecessor – O(1) time Search – O(log n)

8. 8 Binary search 102538475667738495 Successful search: Search(38) 012345678 high mid low

9. 9 Binary search Unsuccessful search: Search(39) 102538475667738495 012345678 high mid low

10. 10 Binary search Key k was found in position mid Key k should be inserted in position mid or mid+1 Key(Retrieve(L,mid))

11. 11 Can we implement all operations in O(log n) time? Yes! Using Binary Search Trees

12. 12 Binary search trees A binary tree in which each node contains a dic-item. Satisfies the binary-search-tree property: If y is in the left subtree of x, then y.key < x.key. If y is in the right subtree of x, then y.key > x.key. 28 7 5101 right info left x parentkey

13. 13 Binary search trees 28 7 5101 right info left x parentkey Dic-Item ≡ Tree-Node left, right, parent are initially null D.root

14. 14 A set can be represented using several different trees 1 8 2 710 5 28 7 5 1 Height – length of a longest path to a leaf height=2 height=4 0 0 0 1 0 2 11 0 2 4 3

15. 15 Tree-Search(x,k) – Look for k in the subtree of x 2 8 7 5 10 1 x Tree-Search(x,5) x x Search(D,k)  Tree-Search(D.root,k) We usually start the search at the root of the tree:

16. 16 Tree-Position(x,k) – Look for k in the subtree of x Return the last node encountered 2 8 7 5 10 1 x Tree-Position(x,6) x x y y y Returns the node containing 5 Tree-Position(x,k) is used to find insertion points

17. 17 Printing the elements of a BST in sorted order (In-order walk) 2 8 7 5101 0 1 2 3 4 5 Printing, of course, is just an example…

18. 18 Finding the minimum “keep going left” 2 8 7 5101

19. 19 Successor(x) If x has a right child, the successor of x is the minimal element in x.right. x What if x.right=null ? “Go right once, and then left all the way”

20. 20 x Successor(x) If x.right=null, the successor of x is the lowest ancestor y of x such that x is in its right subtree y “Go up from x until the first turn right’’

21. 21 x Successor(x) y If x has the largest key, then Successor(x)=null. Predecessor is symmetric

22. 22 Insertions and deletions

23. 23 28 7 5101 Insertions Insert(6) Insert(9) 69

24. 24 Binary Search Tree Animations For the time being, turn all buttons on the right off http://webdiis.unizar.es/asignaturas/EDA/AVLTree/avltree.html Warning: There are some differences with what we learn

25. 25 28 7 5101 Deletion: easy cases first Delete(6) – 6 is a leaf; simply remove it. Delete(8) – 8 has only one child; bypass it. 69 Delete(2) – more complicated… Delete(10) – 10 has only one child; bypass it.

26. 26 Deletion of a binary node z y If z has two children, let y be the successor of z y has no left child Remove y from the tree Replace z by y Binary-search-tree property preserved! Is it enough to let z.key  y.key? And maybe also z.info  y.info?

27. 27 Analysis Each operation takes O(h+1) time, where h is the height of the tree In general h may be as large as n Want to keep the tree with small h

28. 28 Balanced trees h = log 2 (n+1)−1 How do we keep the tree more or less balanced? A full tree of height h contains n=2 h+1 − 1 nodes

29. 29 Randomly built BSTs Maybe balancing will take care of itself? Not if we insert the elements in sorted order. We get a path of length n Things are usually ok if we insert the elements in random order Theorem: If n distinct keys are inserted into a BST in random order, then the expected height of the tree is O(log n). We want worst-case results…

30. 30 Rotations x y B C A y x B A C Right rotate Left rotate