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: don’t 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)