CSCE 3110 Data Structures & Algorithm Analysis Rada Mihalcea Dictionaries. Reading Weiss Chap. 5, Sec

Dictionaries A dictionary is a collection of elements each of which has a unique search key Uniqueness criteria may be relaxed (multiset) (I.e. do not force uniqueness) Keep track of current members, with periodic insertions and deletions into the set Examples Membership in a club, course records Symbol table (contains duplicates) Language dictionary (WordSmith, Webster, WordNet) Similar to database

Course Records Dictionary Member Record keystudent namehw Stan Smith Sue Margolin Billie King Roy Miller39...

Dictionary ADT simple container methods:size() isEmpty() elements() query methods:findElement(k) findAllElements(k) update methods:insertItem(k, e) removeElement(k) removeAllElements(k) special element NO_SUCH_KEY, returned by an unsuccessful search

How to Implement a Dictionary? Sequences / Arrays ordered unordered Binary Search Trees Skip lists Hashtables

Recall Arrays … Unordered array searching and removing takes O(?) time inserting takes O(?) time applications to log files (frequent insertions, rare searches and removals)

Ordered array searching takes O(log n) time (binary search) inserting and removing takes O(n) time application to look-up tables (frequent searches, rare insertions and removals) Apply binary search More Arrays

narrow down the search range in stages “high-low” game findElement(22) Binary Searches

Implement a dictionary with a BST A binary search tree is a binary tree T such that each internal node stores an item (k, e) of a dictionary. keys stored at nodes in the left subtree of v are less than or equal to k. keys stored at nodes in the right subtree of v are greater than or equal to k. Recall Binary Search Trees…

An Alternative to Arrays Unordered Array: insertion: O(1) search: O(n) Ordered Array insertion: O(n) search: O(log n) Skip Lists: insertion: O(log n) search: O(log n) And avoid the fixed-size drawback of arrays!

Skip Lists good implementation for a dictionary a series of lists {S0, S1, …, Sk} each list Si stores a sorted subset of the dictionary D - - 18 -- -- S0 S1 S2 S3

Skip Lists list S(i+1) contains items picked at random from S(i) each item has probability 50% of being in the upper level list like flipping a coin S0 has n elements S1 has about n/2 elements S2 has about n/4 elements …. S(i) has about ? elements

Traversing Positions in a Skip List Assume a node P in the skip list after(p) before(p) below(p) above(p) Running time of each operation?

Operations in a Skip List Use skip lists to implement dictionaries  Need to deal with Search Insert Remove

Searching Search for key K Start with p = the top-most, left position node in the skip list two steps: 1. if below(p) is null then stop we are at the bottom 2. while key(p) < K move to the right go back to 1

Searching Search for - - 18 -- -- S0 S1 S2 S3

More Searching Search for - - 18 -- -- S0 S1 S2 S3

Pseudocode for Searching Algorithm SkipSearch(k) Input: Search key k Output: Position p in S such that p has the largest key less than or equal to k p = top-most, left node in S while below(p) != null do p  below(p) while(key (after(p))  k do p  after(p) return p

Running Time Analysis log n levels  O(log n) for going down in the skip list at each level, O(1) for moving forward why? works like a binary search in skip lists, the elements in list S(i+1) play the role of search dividers for elements in S(i) (in binary search: mid-list elements to divide the search) total running time: O(log n)

Insertion in Skip Lists First: identify the place to insert new key k  node p in S0 with largest key less or equal than k Insert new item(k,e) after p with probability 50%, the new item is inserted in list S1 with probability 25%, the new item is inserted in list S2 with probability 12.5%, the new item is inserted in list S3 –with probability 6.25%, the new item is inserted in list S4 –….

Insertion in Skip Lists Insert - - 18 -- -- S0 S1 S2 S3 29

Pseudocode for Insertion Algorithm SkipInsert(k,e) Input: Item (k,e) Output: - p  SkipSearch(k) q  insertAfterAbove(p, null, Item (k,e)) while random( )  50% do while(above(p) == null) do p  before(p) p  above(p) q  insertAfterAbove(p, q, Item(k,e))

Running Time for Insertion? Search position for new item(k,e) O(log n) Insertion O(1) Total running time O(log n)

Removal from Skip Lists Easier than insertion Locate item with key k to be removed if no such element, return NO SUCH KEY otherwise, remove Item(k,e) remove all items found with above(Item(k,e))

Removal from Skip Lists Remove 18 Running time? - - 18 -- -- S0 S1 S2 S3

Efficient Implementation of Skip Lists use DoublyLinkedList implementation + two additional pointers above below For a LinkedList  provide pointer to head For a DoublyLinkedList  provide pointers to head and tail For a SkipList  ??