Dictionaries CS 110: Data Structures and Algorithms First Semester, 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) 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) 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; } 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 Dictionary Implementations Unordered list Ordered table Binary search tree 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 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: dont do a linear scan; instead, do a binary search Note: use array/ArrayList; not a linked list 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 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 ) BinarySearch( S, someKey, 0, size-1 ); array of Entries target key Binary Search Algorithm lowmidhigh find(22) mid = (low+high)/2 Binary Search Algorithm highlowmid find(22) mid = (low+high)/2 Binary Search Algorithm low midhigh find(22) mid = (low+high)/2 Binary Search Algorithm low=mid=high find(22) mid = (low+high)/2 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 ) Time Complexity O( log n ) O( n ) find() O(n ) Ordered Table O( n )O( 1 )Unsorted List remove()insert()Operation Binary Search Tree (BST) Strategy: store entries as nodes in a tree such that an in-order 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 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 ) ) Insertion in a BST (insert 78) Insertion in a BST (insert 78) Insertion in a BST (insert 78) Insertion in a BST (insert 78) Insertion in a BST (insert 78) Insertion in a BST (insert 78) Insertion in a BST (insert 78) Insertion in a BST (insert 78) Insertion in a BST (insert 78) Removal from a BST (Ex 1) Removal from a BST (Ex 1) Remove 32 Removal from a BST (Ex 1) Removal from a BST (Ex 1) Removal from a BST (Ex 1) Removal from a BST (Ex 1) Removal from a BST (Ex 1) Removal from a BST (Ex 1) Removal from a BST (Ex 2) Remove 65 Removal from a BST (Ex 2) Removal from a BST (Ex 2) 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 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 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 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)