Chapter 8: Dictionaries I

• The primary use of a dictionary is to store elements so that they can be located quickly using keys.
• Like a priority queue, a dictionary is a container of key-element pairs.
• Nevertheless, although a total order relation on the keys is always required for a priority queue, it is optional for a dictionary.
• Indeed, the simplest form of a dictionary assumes only that we can determine whether two keys are equal.
• When the total order relation on the keys is defined, then we can talk about an ordered dictionary, and we specify additional ADT functions that refer to the ordering of the keys.

8.1 The Dictionary Abstract Data Type

• A dictionary ADT stores key-element pairs (k,e) which we call items, where k is the key and e is the element.
• In an unordered dictionary we can use an equality tester object to test whether two keys, k₁ and k₂, are equal with function isEqualTo(k₁, k₂).

• The dictionary ADT models a searchable collection of key-element items
• The main operations of a dictionary are searching, inserting, and deleting items
• Multiple items with the same key are allowed
• Applications:
• address book
• credit card authorization
• mapping host names (e.g., www.nbu.bg) to internet addresses (e.g., 193.19.172.24)
• As an ADT, a dictionary D supports the following functions:

• Remarks:
  
• The way the items of a dictionary are stored is implementation dependent.
• The notation p(x) indicates the position of the item storing element x.
• Example:

• Position class provides:

• A simple way of realizing a dictionary is to use an unordered vector, list, or general sequence to store the key-element pairs.
• Such an implementation is called a log file.

• A log file is a dictionary implemented by means of an unsorted sequence
• We store the items of the dictionary in a sequence (based on a doubly-linked lists or a circular array), in arbitrary order
• Performance:
• insertItem takes O(1) time since we can insert the new item at the beginning or at the end of the sequence
• find and removeElement take O(n) time since in the worst case (the item is not found) we traverse the entire sequence to look for an item with the given key
• The log file is effective only for dictionaries of small size or for dictionaries on which insertions are the most common operations, while searches and removals are rarely performed (e.g., historical record of logins to a workstation)

• closestBefore(k) - Return a position of an item with the largest key less than or equal to k.
• closestAfter(k) - Return a position of an item with the smallest key greater than or equal to k.

• A lookup table is a dictionary implemented by means of a sorted sequence
• We store the items of the dictionary in an array-based sequence, sorted by key
• We use an external comparator for the keys
• Performance:
• find takes O(log n) time, using binary search
• insertItem takes O(n) time since in the worst case we have to shift n/2 items to make room for the new item
• removeElement takes O(n) time since in the worst case we have to shift n/2 items to compact the items after the removal
• The lookup table is effective only for dictionaries of small size or for dictionaries on which searches are the most common operations, while insertions and removals are rarely performed (e.g., credit card authorizations)

• Binary search performs operation find(k) on a dictionary implemented by means of an array-based sequence, sorted by key
• similar to the high-low game
• at each step, the number of candidate items is halved
• terminates after a logarithmic number of steps
• Example: find(7)

bsearch.cpp

Analysis of Binary Search

• The running time is proportional to the number k of recursive calls.
• The number of remaining candidates is reduced by at least one half with each recursive call.
• In the worst case (unsuccessful search), the recursive call stops when there are no more candidates, i.e. n/2^k = 1, k = log n and we obtain O(log n) running time.