Get new post automatically.

Enter your email address:


8.3.1 Direct Address Tables

If we have a collection of n elements whose keys are unique integers in (1,m), where m >= n,
then we can store the items in a direct address table, T[m] ,
where Ti is either empty or contains one of the elements of our collection. Searching a direct address table is clearly an O(1) operation:
for a key, k, we access Tk,

  • if it contains an element, return it,
  • if it doesn't then return a NULL.
There are two constraints here:
  1. the keys must be unique, and
  2. the range of the key must be severely bounded.


If the keys are not unique, then we can simply construct a set of mO(1). However, if each element of the collection has some other distinguishing feature (other than its key), and if the maximum number of duplicates is ndupmax, then searching for a specific element is O(ndupmax). If duplicates are the exception rather than the rule, then ndupmax is much smaller than n and a direct address table will provide good performance. But if ndupmax approaches n, then the time to find a specific element is O(n) and a tree structure will be more efficient. lists and store the heads of these lists in the direct address table. The time to find an element matching an input key will still be
The range of the key determines the size of the direct address table and may be too large to be practical. For instance it's not likely that you'll be able to use a direct address table to store elements which have arbitrary 32-bit integers as their keys for a few years yet!
Direct addressing is easily generalised to the case where there is a function,
h(k) => (1,m)
which maps each value of the key, k, to the range (1,m). In this case, we place the element in T[h(k)] rather than T[k] and we can search in O(1) time as before.