1. Dictionaries CS 105

2. L11: Dictionaries Slide 2 Definition The Dictionary Data Structure structure that facilitates searching objects are stored with search keys; insertion of an object must include a key searching requires a key and returns the key-object pair removal also requires a key Need an Entry interface/class Entry encapsulates the key-object pair (just like with priority queues)

3. L11: Dictionaries Slide 3 Sample Applications An actual dictionary key: word object: word record (definition, pronunciation, etc.) Record keeping applications Bank account records (key: account number, object: holder and bank account info) Student records (key: id number, object: student info)

4. L11: Dictionaries Slide 4 Dictionary Interface public interface Dictionary { public int size(); public boolean isEmpty(); public Entry insert( int key, Object value ) throws DuplicateKeyException; public Entry find( int key ); // return null if not found public Entry remove( int key ) // return null if not found; }

5. L11: Dictionaries Slide 5 Dictionary details/variations Key types For simplicity, we assume that the keys are ints But the keys can be any kind of object as long as they can be ordered (e.g., string and alphabetical ordering) Duplicate entries (entries with the same key) may be allowed Our textbook calls the data structure that does not allows duplicates a Map, while a Dictionary allows duplicates For purposes of this discussion, we assume that dictionaries do not allow duplicates

6. L11: Dictionaries Slide 6 Dictionary Implementations Unordered list (section 8.3.1) Ordered table (section 8.3.3) Binary search tree (section 9.1)

7. L11: Dictionaries Slide 7 Unordered list Strategy: store the entries in the order that they arrive O( 1 ) insert operation Can use an array, ArrayList, or linked list Find operation requires scanning the list until a matching key value is found Scanning implies an O( n ) operation Remove operation similar to find operation Entries need to be adjusted if using array/ArrayList O( n ) operation

8. L11: Dictionaries Slide 8 Ordered table Idea: if the list was ordered by key, searching is simpler/easier Just like for priority queues, insertion is slightly more complex Need to search for proper position of element -> O( n ) Find: don’t do a linear scan; instead, do a binary search Note: use array/ArrayList; not a linked list

9. L11: Dictionaries Slide 9 Binary search Take advantage of the fact that the elements are ordered Compare the target key with middle element to reduce the search space in half Repeat the process until the element is found or search space reduces to 1 Arithmetic on array indexes facilitate easy computation of middle position Middle of S[low] and S[high] is S[(low+high)/2] Not possible with linked lists

10. L11: Dictionaries Slide 10 Binary Search Algorithm Algorithm BinarySearch( S, k, low, high ) if low > high then return null; // not found else mid  (low+high)/2 e  S[mid]; if k = e.getKey() then return e; else if k < e.getKey() then return BinarySearch( S, k, low, mid-1 ) else return BinarySearch( S, k, mid+1, high ) array of Entriestarget key BinarySearch( S, someKey, 0, size-1 );

11. L11: Dictionaries Slide 11 Binary Search Algorithm 42578912141719222527283337 lowmidhigh find(22) mid = (low+high)/2

12. L11: Dictionaries Slide 12 Binary Search Algorithm 42578912141719222527283337 highlowmid find(22) mid = (low+high)/2

13. L11: Dictionaries Slide 13 low Binary Search Algorithm 42578912141719222527283337 midhigh find(22) mid = (low+high)/2

14. L11: Dictionaries Slide 14 low=mid=high Binary Search Algorithm 42578912141719222527283337 find(22) mid = (low+high)/2

15. L11: Dictionaries Slide 15 Time complexity of binary search Search space reduces by half until it becomes 1 n -> n/2 -> n/4 -> … -> 1 log n steps Find operation using binary search is O( log n )

16. L11: Dictionaries Slide 16 Time complexity O( log n ) O( n ) find() O(n ) Ordered Table O( n )O( 1 )Unsorted List remove()insert()Operation

17. L11: Dictionaries Slide 17 Binary Search Tree (BST) Strategy: store entries as nodes in a tree such that an inorder traversal of the entries would list them in increasing order Search, remove, and insert are all O( log n ) operations All operations require a search that mimics binary search: go to left or right subtree depending on target key value

18. L11: Dictionaries Slide 18 Traversing a BST Insert, remove, and find operations all require a key First step involves checking for a matching key in the tree Start with the root, go to left or right child depending on key value Repeat the process until key is found or a null child is encountered (not found) For insert operation, duplicate key error occurs if key already exists Operation is proportional to height of tree ( usually O(log n ) )

19. L11: Dictionaries Slide 19 Insertion in BST (insert 78) 44 17 88 32 28 6597 82 54 76 29 80 44 88 65 82 76 80

20. L11: Dictionaries Slide 20 78 Insertion in BST 44 17 88 32 28 6597 82 54 76 29 80 44 88 65 82 76 80

21. L11: Dictionaries Slide 21 78 Removal from BST (Ex. 1) 44 17 88 32 28 6597 82 54 76 29 80 w z Remove 32

22. L11: Dictionaries Slide 22 78 Removal from BST (Ex. 1) 44 17 88 32 28 6597 82 54 76 29 80 44 17 32 w z

23. L11: Dictionaries Slide 23 28 29 78 Removal from BST (Ex. 1) 44 17 88 6597 82 54 76 80 44 17

24. L11: Dictionaries Slide 24 78 Removal from BST (Ex. 2) 44 17 88 32 28 6597 82 54 76 29 80 w Remove 65

25. L11: Dictionaries Slide 25 78 Removal from BST (Ex. 2) 44 17 88 32 28 6597 82 54 76 29 80 44 88 65 82 76 80 w y x 54

26. L11: Dictionaries Slide 26 Removal from BST (Ex. 2) 44 17 88 32 28 6597 82 54 29 44 88 65 82 w 54 78 80 76

27. L11: Dictionaries Slide 27 Time complexity for BSTs O( log n ) operations not guaranteed since resulting tree is not necessarily “balanced” If tree is excessively skewed, operations would be O( n ) since the structure degenerates to a list Tree could be periodically reordered to prevent skewedness

28. L11: Dictionaries Slide 28 Time complexity (average case) O(n )O( log n )O( n )Ordered Table O( log n ) O( n ) find() O( log n ) BST O( n )O( 1 )Unsorted List remove()insert()Operation

29. L11: Dictionaries Slide 29 Time complexity (worst case) O(n )O( log n )O( n )Ordered Table O( n ) find() O( n ) BST O( n )O( 1 )Unsorted List remove()insert()Operation

30. L11: Dictionaries Slide 30 About BSTs AVL tree: BST that “self-balances” Ensures that after every operation, the difference between the left subtree height and the right subtree height is at most 1 O( log n ) operation is guaranteed Many efficient searching methods are variants of binary search trees Database indexes are B-trees (number of children > 2, but the same principles apply)