分离链接散列表C语言实现实例

/* hash_sep.h */

#ifndef _HASH_SEP_H
#define _HASH_SEP_H

#define MIN_TABLE_SIZE    5
struct list_node;
typedef struct list_node *position;
struct hash_tbl;
typedef struct hash_tbl *hash_table;
typedef unsigned int hash_index;

hash_index hash(const char *key, int table_size);
hash_table initialize_table(int table_size);
void destroy_table(hash_table h);
position find(char *key, hash_table h);
void insert(char *key, hash_table h);
char *retrieve(position p);

#endif

/* hash_sep.c */

#include "hash_sep.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <error.h>

struct list_node
{
char element[100];
position next;
};

typedef position list;

/* List *the_lists will be an array of lists, allocated later */
/* the lists use headers (for simplicity), */
/* though this wastes space */
struct hash_tbl
{
int table_size;
list *the_lists;
};

hash_index
hash(const char *key, int table_size)
{
unsigned int hash_val = 0;

while(*key != '\0')
hash_val = (hash_val << 5) + *key++;

return hash_val % table_size;
}

hash_table
initialize_table(int table_size)
{
hash_table h;
int i;

if(table_size < MIN_TABLE_SIZE)
{
printf("Table size too small");
return NULL;
}

/* allocate table */
h = malloc(sizeof(struct hash_tbl));
if(h == NULL)
{
perror("malloc");
exit(1);
}

h->table_size = table_size;

/* allocate array of lists */
h->the_lists = malloc(sizeof(list) * h->table_size);
if(h->the_lists == NULL)
{
perror("malloc");
exit(1);
}

/* allocate list headers */
for(i = 0; i < h->table_size; i++)
{
h->the_lists[i] = malloc(sizeof(struct list_node));
if(h->the_lists[i] == NULL)
{
perror("malloc");
exit(1);
}
else
h->the_lists[i]->next = NULL;
}

return h;
}

position
find(char *key, hash_table h)
{

position p;
list l;

l = h->the_lists[hash(key, h->table_size)];
p = l->next;

while(p != NULL && strcmp(p->element, key))
p = p->next;

return p;
}

void
insert(char *key, hash_table h)
{
position pos;
position new_cell;
list l;

pos = find(key, h);
if(pos == NULL)
{
new_cell = malloc(sizeof(struct list_node));
if(new_cell == NULL)
{
perror("malloc");
exit(1);
}
else
{
l = h->the_lists[hash(key, h->table_size)];
new_cell->next = l->next;
strcpy(new_cell->element, key);
l->next = new_cell;
}
}
}

void
destroy_table(hash_table h)
{
int i;

if(h != NULL)
{
for(i = 0; i < h->table_size; i++)
free(h->the_lists[i]);
free(h->the_lists);
free(h);
}
}

char *
retrieve(position p)
{
return p->element;
}

/* hash_test.c */

#include <stdio.h>
#include "hash_sep.h"

int
main(void)
{
position p1;
position p2;
position p3;
char *tmp1;
char *tmp2;
char *tmp3;
char array1[] = "zhu";
char array2[] = "yong";
char array3[] = "chang";
hash_table htp;

htp = initialize_table(10);

insert(array1, htp);
insert(array2, htp);
insert(array3, htp);
p1 = find("zhu", htp);
p2 = find("yong", htp);
p3 = find("chang", htp);
tmp1 = retrieve(p1);
tmp2 = retrieve(p2);
tmp3 = retrieve(p3);

printf("\n%s %s %s\n\n", tmp1, tmp2, tmp3);

destroy_table(htp);
}