散列中的单独链接

Question

I am reading about hashing in Robert Sedwick book on Algorithms in C++

We might be using a header node to streamline the code for insertion into an ordered list, but we might not want to use M header nodes for individual lists in separate chaining. Indeed, we could even eliminate the M links to the lists by having the first nodes in the lists comprise the table

.

class ST
{
    struct node
    {
        Item item;
        node* next;

        node(Item x, node* t)
            { item = x; next = t; }
     };

     typedef node *link;

  private:
     link* heads;
     int N, M;

     Item searchR(link t, Key v)
     {
          if (t == 0) return nullItem;
          if (t->item.key() == v) return t->item;
          return searchR(t->next, v);
     }

   public:
     ST(int maxN)
     {
          N = 0; M = maxN/5;
          heads = new link[M];
          for (int i = 0; i < M; i++) heads[i] = 0;
     }

     Item search(Key v)
         { return searchR(heads[hash(v, M)], v); }

     void insert(Item item)
         { int i = hash(item.key(), M);
           heads[i] = new node(item, heads[i]); N++; }
};

My two questions on above text what does author mean by

1. "We could even eliminate the M links to the lists by having the first nodes in the lists comprise the table." How can we modify above code for this?

2. "we might not want to use M header nodes for individual lists in separate chaining." What does this statement mean.

Answer 1

"We could even eliminate the M links to the lists by having the first nodes in the lists comprise the table."

Consider Node* x[n] vs Node x[n] : the former needs an extra pointer and on-insertion memory allocated for the head Node of every non-empty element, and an extra indirection for every hash table operation, while the latter eliminates the n pointers but requires that any unused elements will be able to be put in some discernable not-in-use state (tracking of which may or may not require extra memory), and if sizeof(Node) size is greater than sizeof(Node*) , it may be more wasteful of memory anyway. The difference in memory use can also affect efficiency of cache use: if the table has a high element to buckets ratio then a Node[] gets the Node data into fewer contiguous memory pages, and if you're iterating (in unsorted order) then it's very cache efficient, whereas Node*[] will jump to separate memory allocations that might be all over the place (or on the other hand, might actually be quite close together in some actually useful: eg if both access patterns and dynamic memory allocation addresses correlate to chronological time of object creation.

How can we modify above code for this?

First, your existing code has a problem: heads[i] = new node(item, heads[i]); overwrites an entry in the hash table without first checking if it's empty... if there's anything there then you should be adding to the list, not overwriting the array.

The design change discussed needs:

link* heads;

...changed to...

node* head;

You'd initialise it like this:

head = new node[M];

Which needs an extra node constructor (if item has an equivalent default constructor, you can leave out its initialisation below)

node() : item(nullItem), next(nullptr) { }

Then there's some knock on changes to the rest of your code that are easy to work through. Basically, you're getting rid of a layer of pointers.

"we might not want to use M header nodes for individual lists in separate chaining." What does this statement mean.

I didn't write it so can't say authoritatively, but it appears to be saying that when designing the list code, a decision might have been made to have an initial Node even in an empty list, as this simplifies code for several list operations. While the extra data-less Node might seem a reasonable price when contemplating "usual" uses of a list, hash tables are unusual in that you want most of the lists chained of the buckets to have 0 or 1 element, and exponentially fewer should be longer and longer. So, such a list implementation is poorly suited to use in a hash table.