编程中常用的重要的数据结构实现（一）之哈希表

结构定义如下： （注：实现方式有很多种，这只是其中一种，但大体思路都差不多）

typedef struct {

void* data;

unsigned int len;

}chashdatum;

struct chashcell {

unsigned int func;

chashdatum key;

chashdatum value;

struct chashcell* next;

};

typedef struct {

unsigned int count;

unsinged int size;

chashcell** cells;

}chash;

typedef chashiter chashcell;

#define DEFAULT_HASH_SIZE 12

#define CHASH_MAXDEPTH 3

哈希表的函数实现：

chash* hash_new(int size)

{

chash* hash = (chash*)malloc(sizeof(chash));

if (NULL == hash)

return NULL;

if (size < DEFAULT_HASH_SIZE )

size = DEFAULT_HASH_SIZE;

hash->cells = (strcut chashcell**)malloc(size * sizeof(struct chashcell* ));

if (NULL == hash->cells)

{

free(hash);

return NULL;

}

hash->count = 0;

hash->size = size;

return hash;

}

unsigned int chash_func(const char* key, unsigned int len)

{

register unsigned int c = 5381;

register const char* k = key;

while (len --)

{

c = ( (c<<5) + c) + *k++;

}

return c;

}

int chash_get(chash* hash, chashdatum* key, chashdatum* result)

{

chashiter* iter;

unsigned int func = chash_func(key->data, key->len );

iter = hash->cells[func % hash->size];

while (iter)

{

if (iter->key.len == key->len && func == iter->func && !memcmp(iter->key.data, key->data, key->len))

{

*result = iter->value;

return 0;

}

iter = iter->next;

}

return -1;

}

int chash_set(chash* hash, chashdatum* key, chashdatum* value)

{

int count = hash->count + 1;

if ( count > hash->size * CHASH_MAXDEPTH)

{

int r = chash_resize(hash, (hash->count / CHASH_MAXDEPTH) * 2 + 1);

if (r < 0)

retrurn -1;

}

unsigned int func = chash_func(key->data, key->len);

unsigned int indx = func % hash->size;

chashiter* iter = hash->cells[index];

chashiter* cell = NULL;

while(iter)

{

if (iter->key.len == key->len && func == iter->func && !memcmp(iter->key.data, key->data, key->len))

{

iter->value = value;

return 0;

}

iter = iter->next;

}

cell = (struct chashcell*) malloc (sizeof(struct chashcell));

if (NULL == cell)

return -1;

cell->key.data = key->data;

cell->key.len = key->len;

cell->value.data = value->data;

cell->value.len = value->len;

cell->func = func;

cell->next = hash->cells[indx];

hash->cells[indx] = cell;

hash->count++;

return 0;

}

int chash_resize(chash* hash, unsigned int size)

{

strcut chashcell** cells;

chashiterl* iter, *next;

unsigned int indx, nindx;

if (size == hash->size)

return 0;

cells = (struct chashcell**)malloc(size * sizeof(struct chashcell*));

if (NULL == cells)

return -1;

for (indx = 0; indx < hash->size; indx++)

{

iter = hash->cells[indx];

while (iter)

{

next = iter->next;

nindx = iter->func % size;

iter->next = cells[nindx];

cells[nindx] = iter;

iter = next;

}

}

free(hash->cells);

hash->cells = cells;

hash->size = size;

return 0;

}

void chash_free(chash* hash)

{

int indx;

chashiter* iter, *next;

for (indx = 0; indx < hash->size; indx++)

{

iter = hash->cells[indx];

while (iter)

{

next = iter->next;

free(iter);

iter = next;

}

}

free(hash->cells);

free(hash);

}

int chash_delete(chash* hash, chashdatum* key)

{

unsigned int func = chash_func(key->data, key->len);

int indx = func % hash->size;

chashiter* iter = hash->cells[indx];

while (iter)

{

if (iter->key.len == key->len && iter->func == func && !memcmp(iter->key.data, key->data, key->len) )

{

chash->cells[indx] = iter->next;

free(iter);

chash->count--;

return 0;

}

iter = iter->next;

}

return -1;

}

void chash_clear(chash* hash)

{

int indx;

chashiter* iter;

for(indx = 0; indx < hash->size; indx++)

{

iter = hash->cells[indx];

while (iter)

{

next = iter->next;

free(iter);

iter = next;

}

}

memset(hash->cells, 0, hash->size * sizeof( struct chashcell*) );

hash->count = 0;

}

chashiter* chash_begin(chash* hash)

{

chashiter* iter;

int indx = 0;

iter = hash->cells[indx];

while (!iter)

{

indx++;

if (indx >= hash->size)

return NULL;

iter = hash->cells[indx];

}

return iter;

}

chashiter* chash_next(chash* hash, chashiter* iter)

{

int indx = iter->func % hash->size;

if (!iter)

return NULL;

iter = iter->next;

while(!iter)

{

indx++;

if (indx >= hash->size)

return NULL;

iter = hash->cells[indx];

}

return iter;

}

int chash_count(chash* hash)

{

return hash->count;

}

int chash_size(chash* hash)

{

return hash->size;

}

void chash_key(chashiter* iter, chashdatum* result)

{

*result = iter->key;

}

void chash_value(chashiter* iter, chashdatum* result)

{

*result = iter->value;

}