An STL-Compatible Hybrid of Linked List and Hash Map

William Nagel, Dr. Dobb’s Journal, August 2005

Presentation by Phil Ulrich

The Requirements

Need a data structure that provides very high random-access performance.

Also need a data structure that provides high performance while iterating through it.

The project in the article was in C++, so the STL was the natural assumption, but the STL was insufficient.

Shortcomings of the Hash Map

Constant-time random access in the average case (one key = one value), so it meets one requirement

However, the hash map begins degrading if one key has multiple values

Furthermore, iteration is proportional to the number of keys AND the number of values

Shortcomings of Maps, Arrays and Linked Lists The map only offers “decent”

performance, so it is out of the question Arrays and linked lists have decent

iterative access, but random access requires linear search

Furthermore, an array would require costly resizing functions as items are added or deleted

Linked List + Hash Map = linked_hash The linked_hash is a hybrid of a linked

list and a hash map, as its name implies.

It allows elements to be accessed in constant time using a key.

In addition, the structure supports linear-time iteration through the elements by storying them as a linked-list.

Building the linked_hash

The linked_hash follows the interface for the GNU STL hash_map.

The class, while behaving like a linked list, does not support LL-specific functions such as push_front(), push_back(), or insertion at a specific position.

Building the linked_hash (cont.)

The values are not stored directly in the node, but in a _linked_hash_node structure.

The internal list and hash_map then store pointers to nodes.

The class has an iterator, to easily move through the linked list. It can also be accessed via key.

Building the linked_hash (cont.)

The parameters match those of the hash_map structure: key, data type, hash function, class for testing equality of two keys, and allocator class.

The constructor also matches that of the hash_map.

For many simple functions, such as size(), empty(), bucket_size(), and so on, the underlying hash_map function is called.

insert(), erase(), and operator[]

insert() and erase() are interesting because they have to add something to the hash and the list. This is, in general, done to the internal hash_map first, then the internal linked list.

operator[] allows both access AND return by checking to see if an item exists first.

Where could this be used?

The linked_hash can be used pretty much anywhere an STL map or hash_map would be used.

This is because it has an STL-compatible interface.

How does it perform? In the article, three test batteries were performed:

insertion tests, modification tests, and iterations. The linked_hash was never the best performer in

any test. However, no other structure was able to

consistently outperform the linked_hash. The conclusion we can draw from that is that the

linked_hash, while not offering the peak performances of some other structures, allows better overall performance.

Where could it be improved?

Ordering: the linked_hash, by default, inserts items unordered, thus making iteration unlikely to be in any given order. A sorted structure could replace the internal linked list to help this.

Multiples: right now, the linked_hash supports one key = one item. To change this, a hash_set could be used instead of a hash_map.