Chapter 8

The Map
ADT
 Chapter 8: The Map ADT
8.1 – The Map Interface
8.2 – Map Implementations
8.3 – Application: String-to-String Map
8.4 – Hashing
8.5 – Hash Functions
8.6 – A Hash-Based Map
8.7 – Map Variations
 8.1 The Map Interface
• Maps associate a
key with exactly
one value
• In other words
– a map structure
does not permit
duplicate keys
– but two distinct
keys can map onto
the same value
Legal mapping variations
 MapInterface
//------------------------------------------------------------------------/
/ MapInterface.java by Dale/Joyce/Weems Chapter
8 //
// A map provides (K = key, V = value) pairs, mapping the key onto
// the value.
// Keys are unique. Keys cannot be null.
//
// Methods throw IllegalArgumentException if passed a null key argument.
//
// Values can be null, so a null value returned by put, get, or remove does
// not necessarily mean that an entry did not exist.
//------------------------------------------------------------------------
//
// . . . continued on next slide
package ch08.maps;
import java.util.Iterator;

public interface MapInterface<K, V> extends Iterable<MapEntry<K,V>>

{
V put(K k, V v);
// If an entry in this map with key k already exists then the value
// associated with that entry is replaced by value v and the original
// value is returned; otherwise, adds the (k, v) pair to the map and
// returns null.

V get(K k);
// If an entry in this map with a key k exists then the value associated
// with that entry is returned; otherwise null is returned.

V remove(K k);
// If an entry in this map with key k exists then the entry is removed
// from the map and the value associated with that entry is returned;
// otherwise null is returned.
//
// Optional. Throws UnsupportedOperationException if not supported.

// Also requires contains(K key), isFull(), isEmpty() and size()

}
 Iteration
• We require an iteration that returns key-value
pairs
• The class MapEntry represents the key-value
pairs
– requires the key and value to be passed as
constructor arguments
– provides getter operations for both key and value
– provides a setter operation for the value
– provides a toString
 MapExample
• Instructors can now discuss and demonstrate
the MapExample application found in the
ch08.apps package … it uses the
ArrayListMap class presented in the next
section
 8.2 Map Implementations
• Unsorted Array
– The put operation creates a new MapEntry object
and performs a brute force search (O(N)) of all the
current keys in the array to prevent key duplication
– If a duplicate key is found, then the associated
MapEntry object is replaced by the new object and
its value attribute is returned, for example
map.put(cow)
 Map Implementations
• Unsorted Array
– Like put, the get, remove, and contains
operations would all require brute force searches of
the current array contents, so they are all O(N)
• Sorted Array
– The binary search algorithm can be used, greatly
improving the efficiency of the important get and
contains operations.
– Although it is not a requirement, in general it is
expected that a map will provide fast implementation
of these two operations.
 Map Implementations
• Unsorted Linked List
– Similar to an unsorted array, most operations require
brute force search
– In terms of space, a linked list grows and shrinks as
needed so it is possible that some advantage can be
found in terms of memory management, as compared
to an array.
 Map Implementations
• Sorted Linked List
– Even though a linked list is kept sorted, it does not
permit use of the binary search algorithm as there is
no efficient way to inspect the “middle” element.
– So there is not much advantage to using a sorted
linked list to implement a map, as compared to an
unsorted linked list
 Map Implementations
• Binary Search Tree
– If a map can be implemented as a balanced binary
search tree, then all of the primary operations (put,
get, remove, and contains) can exhibit efficiency
O(log2N).
 ArrayListMap
• Instructors can now discuss the ArrayListMap
class found in the ch08.maps package and
review the associated notes found on pages 511
and 512
 8.3 Application:
String-to-String Map
• The StringPairApp found in the ch08.apps
package reads # separated pairs of strings (key
# value) from specified input file and then allows
the user to enter keys and reports back to them
the associated value if there is one.
• It is a short yet versatile application that
demonstrates the use of our Map ADT
 8.4 Hashing
• An efficient approach to implementing a Map
• Typically provides O(1) operation
implementation
• Uses an array (typically called a hash table) to
hold the key/value pairs
• Hashing involves determining array indices
directly from the key of the entry being
stored/accessed.
 Compression function
• If we have a positive
integral key, such as an
ID number, we can just
use the key as the index
into the array
• If the range of key
values is larger than the
array we must
“compress” the key into
a usable index
 Collisions
• If two keys compress to the same array location
we call it a “collision”
• minimizing such collisions is the biggest
challenge in designing a good hashing system
– we cover this in Section 8.5, “Hash Functions.”
• In our discussion of collision resolution policies,
we will assume
– use of an array info to hold the information
– the int variable location to indicate an array/hash-
table slot.
 Collision resolution policies
• Linear probing: store the colliding entry into the
next available space:
 Item Removal
• Complicates searching: can not terminate search
upon finding a null entry therefore:
– use a special value for a removed entry
– use a boolean value associated with each hash table slot:
– disallow removal
 Collision resolution policies
• Linear probing approach can lead to inefficient
clusters of entries
• Quadratic probing: the value added at each
step is dependent on how many locations have
already been inspected.
– The first time it looks for a new location it adds 1 to
the original location
– the second time it adds 4 to the original location
– the third time it adds 9 to the original location
– and so on—the ith time it adds i2:
Comparison
Collision resolution policies
Buckets and Chaining
 8.5 Hash Functions
• To get the most benefit from a hashing system
we need for the eventual locations used in the
underlying array to be as spread out as possible.
• Two factors affect this spread
– the size of the underlying array
– the set of integral values presented to the
compression function
 Array Size
• space versus time trade-off
• hash systems will often monitor their own load—
the percentage of array indices being used
• Once the load reaches a certain level, for
example 75%, the system is rebuilt using a
larger array
• This approach is often called “rehashing”
because after the array is enlarged all of the
previous entries have to be reinserted into the
new array
 The Hash Function
• Keys might not be integral
• Even if integral, keys might not provide a good
“spread”
• So, we add another step, the hash function:

• Synonyms for “hash code” include “hash value,”

and sometimes we just use the word “hash.”
 Creating a hash function
• Selecting: Identify selected parts of the key – try
to use parts that will provide a good variety of
results
• Digitizing: the selected parts must be
transformed to integers
• Combining: combine the resultant integers using
a mathematical function
 Considerations
• A hash code is not unique. Do not use a hash code as a
key.
• If two entries are considered to be equal, then they
should hash to the same value.
• When defining a hash function, consider the work
required to calculate it.
• A precise analysis of the complexity of hashing depends
on the domain and distribution of keys, the hash
function, the size of the table, and the collision resolution
policy. In practice it is usually not difficult to achieve
close to O(1) efficiency using hashing.
 Java’s Support for Hashing
• The Java Library includes a HashMap class (discussed
in Section 8.7) and a HashSet class that use hash
techniques to support storing objects
• The Java Object class exports a hashCode method
that returns an int hash code.
– The standard Java hash code for an object is a function of the object’s memory
location.
• For most applications, hash codes based on memory
locations are not usable. Many of the Java classes that
define commonly used objects (such as String and
Integer), override the Object class’s hashCode
method.
• If you plan to use hash tables in your programs, you
should do likewise.
 8.6 A Hash-Based Map
Hmap.java
• is implemented with an internal hash table that
uses the hashCode method of the key class
• is unbounded
• has a default capacity of 1,000 and a default
load factor of 75%
• does not support the remove operation
• is located in the ch08.maps package
• is used by the VocDensMeasureHMap
application located in the ch08.apps package
 8.7 Map Variations
• Some programming languages, (e.g., Awk,
Haskell, JavaScript, Lisp, MUMPS, Perl, PHP,
Python, and Ruby), directly support
• Many other languages, including Java, C++,
Objective-C, and Smalltalk provide map
functionality through their standard code libraries
 Maps are known by many names:
• Symbol table - one of the first carefully studied and
designed data structures, and were related to compiler
design
• Dictionary - the idea of looking up a word (the key) in a
dictionary to find its definition (the value) makes the
concept of a dictionary a good fit for maps
• Hashes - because a hash system is a very efficient and
common way to implement a map, you will sometimes
see the two terms used interchangeably
• Associative Arrays - You can view a map as an array—
one that associates keys with values rather than indices
with values.