查找算法哈希表

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 10000
char str[MAX_N + 5] = {
    
    0};


typedef struct Node {
    
    
	char* str;
	struct Node* next;
}Node;

typedef struct HashTable {
    
    
	Node** data;
	int size;
}HashTable;


Node* init_Node(char* str, Node* head) {
    
    
	Node* p = (Node*)malloc(sizeof(Node));
	p->str = _strdup(str);
	p->next = head;
	return p;
}

HashTable* init_hash(int n) {
    
    
	HashTable* h = (HashTable*)malloc(sizeof(HashTable));
	h->size = n << 1;
	h->data = (Node**)calloc(h->size, sizeof(Node*));
	return h;
}

int BKDRHash(char* str) {
    
    
	int seed = 31, hash = 0;
	for (int i = 0; str[i]; i++) {
    
    
		hash = hash * seed + str[i];
	}
	return hash & 0x7fffffff;
}

int insert(HashTable* h, char* str) {
    
    
	int hash = BKDRHash(str);
	int ind = hash % h->size;
	h->data[ind] = init_Node(str, h->data[ind]);
	return 1;
}

int search(HashTable* h, char* str) {
    
    
	int hash = BKDRHash(str);
	int ind = hash % h->size;
	Node* p = h->data[ind];
	while (p && (strcmp(p->str, str))) p = p->next;
	return p != NULL;
}

void clear_node(Node* head) {
    
    
	if (head == NULL) return;
	Node* p = head, * q;
	while (p != NULL) {
    
    
		q = p->next;
		free(q);
		p = q;
	}
	return;
}

void clear(HashTable* h) {
    
    
	if (h == NULL) return;
	for (int i = 0; i < h->size; i++) {
    
    
		clear_node(h->data[i]);
	}
	free(h->data);
	free(h);
	return;
}

int main() {
    
    
	HashTable* h = init_hash(MAX_N);
	int op;
	while (~scanf("%d%s", &op, str)) {
    
    
		switch (op) {
    
    
		case 0 :
			printf("insert %s to HashTable\n", str);
			insert(h, str);
			break;
		case 1:
			printf("search %s from HashTable result = %d \n", str, search(h, str));
			break;
		}
	}
#undef MAX_N
	clear(h);
	return 0;
}