C 中的哈希散列

Question

I'm kind of new in C because moving back to that after 6 years! wanna Implement a code to store tree for this data like this :

string1 = "foo.bar.foo.\\*" string2 = "foo.baz.\\*" string3 = "foo.\\*.bar"

     foo
      |
  |   |   |
 bar baz  *
  |   |   |
 foo  *  bar
  |
  *

trying to do this with HashTable :

struct entry_s {
    char *key;
    struct entry_s *value;
    struct entry_s *next;
};

but I dont think it works, what is the best way to do that and even though is Hash Map the best data structure that could be used in C?

Answer 1

It seems that you want to implement a map with two levels: The first level maps strings to second-level maps and the second-level maps another key to a value. For example, in Javascript syntax:

data = {
    "London": {
        "Paris": 450
    },
    "Paris": {
       "Madrid": 600,
       "Algiers": 700
    }
}

There are several ways to achieve this.

Javascript variables carry their types with them, so yozu can use the same Map implemantation for both levels. In C, you could implement two hash tables with different value types, eg:

struct OItem {                  // Outer map item
    const char *key;                // string key
    struct IMap *value;             // inner map value
    struct OItem *next;         
};

struct OMap {                   // Outer map
    struct OItem *head[oSize];      // hash table
};

struct IItem {                  // Inner map item
    const char *key;                // string key
    int value;                      // integer value
    struct IItem *next;
};

struct IMap {                   // Inner map
    struct IItem *head[iSize];      // hash table
};

This will give you the two-level structure above. (These hash tables have fixed sizes, so that you might end up wasting a lot of space when for example the second-level maps are sparse. Perhaps it might be better to use just a single list or a balanced tree here. If you use the second-level map just emulates an object that always hash the same or similar data, consider using a struct here.)

You can use this structure and lookup("London", "Paris") , for example. If you don't need access to the inner map, you could also pack both levels into one big hash table by using two keys:

struct Item {
    const char *key1;
    const char *key2;
    int value;
    struct Item *next;
};

struct Map {
    struct Item *head[hSize];
};

When you calculate a hash, use both keys, for example:

static unsigned int hash(const char *s1, const char *s2)
{
    unsigned long hash = 5381u;

    while (*s1) hash = hash * 33 ^ *s1++;
    hash = hash *33;
    while (*s2) hash = hash * 33 ^ *s2++;

    return hash;
}

When you look up an item, ensure that both keys match:

int map_find(const struct Map *map,
    const char *k1, const char *k2)
{
    unsigned int h = hash(k1, k2) % hSize;
    struct Item *item = map->head[h];

    while (item) {
        if (strcmp(item->key1, k1) == 0
         && strcmp(item->key2, k2) == 0) {
            return item->value;
        }

        item = item->next;
    }

    return 0;
}

This approach is perhaps more restrictive, but has the advantage that you don't have many potentially oversized hash tables, but just one data structure.

Finally, whatever you do, don't use the hash table implementation you found on GitHub. The author admits that it was more of a coding exercise. It doesn't deal with releasing the memory after use and has a poor hash function.

---

After you edited in your actual use case, it is clear that you want a trie . You can implement a trie as you suggested. The keys and values can be anything in your implementation, so they can also be strings and trie nodes. You can adappt your existing implementation to use a pointer to a trie node structure as values. (All the comparison stuff stays the same, fortunately.)

One problem I see is that with a fixed hash-table size, you will end up wasting a lot of space. If your trie is sparse, it might be better to just use a linked list or a balanced binary tree as map. In any case, you will have to find a suitable lib or roll your own.

Answer 2

Your question doesn't really make sense, and I think it's because you don't really understand how hash tables would work, so here's some (crude and untested) code to show you how they'd work:

typedef struct entry_s {
    char *key;
    char *value;
    struct entry_s *next;
} entry_t;

#define MAX_HASH 1234;

entry_t *myHashTable[MAX_HASH];


void insert(char *key, char *value);
    entry_t *entry;

    hash = calculateHash(key) % MAX_HASH;

    // Create entry

    entry = malloc(sizeof(entry_t));
    if(entry == NULL) exit(EXIT_FAILURE);
    entry->key = key;
    entry->value = value;

    // Add entry to the singly linked list for this hash

    entry->next = myHashTable[hash];
    myHashTable[hash] = entry;
}


entry *find(char *key) {
    entry_t *entry;

    hash = calculateHash(key) % MAX_HASH;
    entry = myHashTable[hash];
    while(entry != NULL) {
        if(strcmp(key, entry->key) == 0) {
            return entry;
        }
        entry = entry->next;
    }
    return NULL;
}


void delete(char *key) {
    entry_t *previous = NULL;
    entry_t *entry;

    hash = calculateHash(key) % MAX_HASH;
    entry = myHashTable[hash];
    while(entry != NULL) {
        if(strcmp(key, entry->key) == 0) {

            // Remove entry from the singly linked list for this hash

            if(previous == NULL) {
                myHashTable[hash] = entry->next;
            } else {
                previous->next = entry->next;
            }

            // Free the memory and return

            free(entry);
            return;
        }
        previous = entry;
        entry = entry->next;
    }
}

Note: A good understanding of singly linked lists will help you figure out what this example is doing.