In this chapter, we return to the problem of implementing an . The difference now is that we assume the elements stored in the are -bit integers. That is, we want to implement , , and where . It is not too hard to think of plenty of applications where the data--or at least the key that we use for sorting the data--is an integer.
We will discuss three data structures, each building on the ideas of the previous. The first structure, the performs all three operations in time. This is not very impressive, since any subset of has size , so that . All the other implementations discussed in this book perform all operations in time so they are all at least as fast as a .
The second structure, the , speeds up the search in a by using hashing. With this speedup, the operation runs in time. However, and operations in an still take time and the space used by an is .
The third data structure, the , uses an to store only a sample of roughly one out of every elements and stores the remaining elements in a standard structure. This trick reduces the running time of and to and decreases the space to .
The implementations used as examples in this chapter can store any type of data, as long as an integer can be associated with it. In the code samples, the variable is always the integer value associated with , and the method converts to its associated integer. In the text, however, we will simply treat as if it is an integer.