Question

Section 6.6 of K&R discusses a hash table using a linked list.

In short, a hash table is an array of pointers. The pointers point to a linked list. The linked list is a struct that looks like:

struct nlist {             /* table entry: */
    struct nlist *next;    /* next entry in chain */
    char *name;            /* defined name */
    char *defn;            /* replacement text */
};

The name is hashed, and this hash determines the index in the table. The chapter then shows code to add a name/defn pair to the table:

struct nlist *install(char *name, char *defn) {
    struct nlist *np;
    unsigned hashval;
    if ((np = lookup(name)) == NULL) { /* not found */
        np = (struct nlist *) malloc(sizeof(*np));
        if (np == NULL || (np->name = strdup(name)) == NULL)
            return NULL;
        hashval = hash(name);
        np->next = hashtab[hashval];
        hashtab[hashval] = np;
    } else /* already there */
        free((void *) np->defn); /*free previous defn */
    if ((np->defn = strdup(defn)) == NULL)
        return NULL;
    return np;
}

Everything makes sense except for the following 2 lines:

np->next = hashtab[hashval];
hashtab[hashval] = np;

When I try to understand this, I keep coming to the conclusion that the list now links back to itself and if you try to traverse the linked list it will be like a dog chasing its own tail. I would expect the code to set np->next to NULL.

What am I not understanding? How come this code works ?

Answer 1

It results in the new value being inserted at the beginning of the list.

So it goes from:

hashtab[hashval]   -->  original_list

to:

hashtab[hashval]   -->  original_list
np->next           -->  original_list

to:

hashtab[hashval]  -->  *np
        np->next  -->  original_list

The golden rule is, if linked-list code doesn’t make sense, always draw out a diagram!