Algorithms

488 CHAPTER 3 ■ Searching
Our symbol-table implementations are useful for a wide range of applications, but
our algorithms are easily adapted to support several other options that are widely used
and worth considering.
Pr imit ive t y p e s . Suppose that we have a symbol table with integer keys and associated
floating-point numbers. When we use our standard setup, the keys and values
are stored as Integer and Double wrapper-type values, so we need two extra memory
references to access each key-value pair. These references may be no problem in an application
that involves thousands of searches on thousands of keys but may represent
excessive cost in an application that involves billions of searches on millions of keys. Using
a primitive type instead of Key would save one reference per key-value pair. When
the associated value is also primitive, we can eliminate another reference. The situation
is diagrammed at right for separate chaining; the
same tradeoffs hold for other implementations. For
performance-critical applications, it is worthwhile
and not difficult to develop versions of our implementations
along these lines (see Exercise 3.5.4).
Duplicate ke y s . The possibility of duplicate keys
sometimes needs special consideration in symboltable
implementations. In many applications, it is
desirable to associate multiple values with the same
key. For example, in a transaction-processing system,
numerous transactions may have the same
customer key value. Our convention to disallow
duplicate keys amounts to leaving duplicate-key
management to the client. We will consider an example
of such a client later in this section. In many
of our implementations, we could consider the alternative
of leaving key-value pairs with duplicate
standard implementation
data is stored in
Key and Value objects
primitive-type implementation
data is stored in
linked-list nodes
Memory usage for separate chaining
keys in the primary search data structure and to return any value with the given key for
a search. We might also add methods to return all values with the given key. Our BST
and hashing implementations are not difficult to adapt to keep duplicate keys within
the data structure; doing so for red-black BSTs is just slightly more challenging (see Exercise
3.5.9 and Exercise 3.5.10). Such implementations are common in the literature
(including earlier editions of this book).