算法导论代码 第11章 散列表

第11章 散列表

11.2 散列表

#include <stdio.h>
#include <stdlib.h>
/*通过链接法解决碰撞*/
typedef struct hash_chain_type *hash;
typedef struct list_type *list;
struct list_node {
	void *key;
	struct list_node *prev;
	struct list_node *next;
};
struct list_type {
	struct list_node *head;
};
struct hash_chain_type {
	list *list_array;
	int (*get_value) (const void *);
	int num;
};
void list_node_ini(struct list_node *p, void *key)
{
	p->key = key;
	p->prev = NULL;
	p->next = NULL;
}

list list_create()
{
	list l = malloc(sizeof(struct list_type *));
	l->head = NULL;
	return l;
}

void list_destroy(list l, void (*free_key) (void *))
{
	struct list_node *x = l->head;
	while (x != NULL) {
		struct list_node *del = x;
		x = x->next;
		free_key(del->key);
		free(del);
	}

	free(l);
}

struct list_node *list_search(list l, void *k,
			      int (*comp) (const void *, const void *))
{
	struct list_node *x = l->head;
	while (x != NULL && comp(x->key, k) != 0) {
		x = x->next;
	}
	return x;
}

void list_insert(list l, struct list_node *x)
{
	x->next = l->head;
	if (l->head != NULL) {
		l->head->prev = x;
	}
	l->head = x;
	x->prev = NULL;
}

void list_delete(list l, struct list_node *x)
{
	if (x->prev != NULL) {
		x->prev->next = x->next;
	} else {
		l->head = x->next;
	}
	if (x->next != NULL) {
		x->next->prev = x->prev;
	}
}

hash hash_create(int num, int (*get_value) (const void *))
{
	hash h = malloc(sizeof(struct hash_chain_type));
	h->num = num;
	h->get_value = get_value;
	h->list_array = malloc(sizeof(list) * num);
	for (int i = 0; i < num; i++) {
		h->list_array[i] = list_create();
	}
	return h;
}

void hash_destroy(hash h, void (*free_key) (void *))
{
	for (int i = 0; i < h->num; i++) {
		list_destroy(h->list_array[i], free_key);
	};
	free(h->list_array);
	free(h);
}

int hash_value(hash h, int key)
{
	return key % h->num;
}

void hash_insert(hash h, struct list_node *x)
{
	int key = h->get_value(x);
	list l = h->list_array[hash_value(h, key)];
	list_insert(l, x);
}

struct list_node *hash_search(hash h, int key,
			      int (*comp) (const void *, const void *))
{
	list l = h->list_array[hash_value(h, key)];
	return list_search(l, &key, comp);
}

void hash_delete(hash h, struct list_node *x)
{
	if (x == NULL)
		return;
	int key = h->get_value(x);
	list l = h->list_array[hash_value(h, key)];
	list_delete(l, x);
}

/*用于list_node的key成员的比较函数*/
int cmp_int(const void *p1, const void *p2)
{
	const int *pa = p1;
	const int *pb = p2;
	if (*pa < *pb)
		return -1;
	if (*pa == *pb)
		return 0;
	return 1;
}
/*从list_node类型指针中取得关键字的整数值*/
int get_value(const void *x)
{
	const struct list_node *p = x;
	const int *ip = p->key;
	return *ip;
}

int main()
{
	hash h = hash_create(10,get_value);
	for (int i = 0; i < 10; i++) {
		struct list_node *x = malloc(sizeof(struct list_node));
		int *p = malloc(sizeof(int));
		*p = i;
		list_node_ini(x, p);
		printf("%d ", *p);
		hash_insert(h, x);
	}
	printf("\n");
	int k = 0;
	struct list_node *x = hash_search(h, k, cmp_int);
	printf("查找关键字:%d的结果:%s\n", k,
	       x != NULL ? "成功" : "失败");
	if (x != NULL) {
		hash_delete(h, x);
		free(x->key);
		free(x);
		x = hash_search(h, k, cmp_int);
		printf("删除关键字:%d的结果:%s\n", k,
		       x == NULL ? "成功" : "失败");
	}
	hash_destroy(h, free);
	return 0;
}

11.4 开放地址法

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct hash_open_addressing_type *hash;
#define	NIL		((void*)-1)
#define	DELETED ((void*)-2)
struct hash_open_addressing_type {
	void **array;
	int num;
	int (*hash_fun) (hash, int, int);
	int (*get_value) (const void *);
};
hash hash_create(int num, int (*hash_fun) (hash, int, int),
		 int (*get_value) (const void *))
{
	hash h = malloc(sizeof(struct hash_open_addressing_type));
	h->num = num;
	h->array = malloc(sizeof(void *) * num);
	for (int i = 0; i < h->num; i++)
		h->array[i] = NIL;
	h->hash_fun = hash_fun;
	h->get_value = get_value;
	return h;
}

void hash_destroy(hash h, void (*free_key) (void *))
{
	for (int i = 0; i < h->num; i++) {
		if (h->array[i] != NIL && h->array[i] != DELETED) {
			free_key(h->array[i]);
		}
	}
	free(h->array);
	free(h);
}

int hash_insert(hash h, void *p)
{
	int key = h->get_value(p);
	int i = 0;
	int j = 0;
	do {
		j = h->hash_fun(h, key, i);
		if (h->array[j] == NIL || h->array[j] == DELETED) {
			h->array[j] = p;
			return j;
		} else {
			i++;
		}
	} while (i < h->num);
	return -1;
}

/*返回槽的索引*/
int hash_search(hash h, int key)
{
	int i = 0;
	int j = 0;
	do {
		j = (h->hash_fun) (h, key, i);
		if (h->array[j] != DELETED) {
			int value = h->get_value(h->array[j]);
			if (value == key) {
				return j;
			}
		}
		++i;
	} while (h->array[j] != NIL && i < h->num);
	return -1;
}

/*返回槽的索引*/
int hash_delete(hash h, int key)
{
	int i = hash_search(h, key);
	if (i != -1) {
		h->array[i] = DELETED;
	}
	return i;
}

int hash_fun_linear(hash h, int key, int i)
{
	int h1 = key % h->num;
	return (h1 + i) % h->num;
}

int hash_fun_quadratic(hash h, int key, int i)
{
	int h1 = key % h->num;
	return (h1 + i + i * i) % h->num;
}

int hash_fun_double_hash(hash h, int key, int i)
{
	int h1 = key % h->num;
	int h2 = key % h->num + 1;
	return (h1 + i * h2) % h->num;
}

/*从存到hash表里的类型指针中取得关键字的整数值*/
int get_value(const void *x)
{
	const int *ip = x;
	return *ip;
}

int main()
{
	hash h = hash_create(10, hash_fun_double_hash, get_value);
	for (int i = 0; i < 10; i++) {
		int *p = malloc(sizeof(int));
		*p = i;
		printf("%d ", *p);
		hash_insert(h, p);
	}
	printf("\n");
	int k = 0;
	int pos = hash_search(h, k);
	printf("查找关键字:%d的结果:%s\n", k,
	       pos != -1 ? "成功" : "失败");
	int *p = h->array[pos];
	int delete_key = get_value(p);
	hash_delete(h, delete_key);
	free(p);
	pos = hash_search(h, k);
	printf("删除关键字:%d的结果:%s\n", k,
	       pos == -1 ? "成功" : "失败");
	hash_destroy(h, free);
	return 0;
}