Dictionaries CS 105

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)

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)

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; }

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

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

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

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

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

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 );

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

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

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

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

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 )

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

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

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 ) )

L11: Dictionaries Slide 19 Insertion in BST (insert 78)

L11: Dictionaries Slide Insertion in BST

L11: Dictionaries Slide Removal from BST (Ex. 1) w z Remove 32

L11: Dictionaries Slide Removal from BST (Ex. 1) w z

L11: Dictionaries Slide Removal from BST (Ex. 1)

L11: Dictionaries Slide Removal from BST (Ex. 2) w Remove 65

L11: Dictionaries Slide Removal from BST (Ex. 2) w y x 54

L11: Dictionaries Slide 26 Removal from BST (Ex. 2) w

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

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

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

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)