简单哈希实现

#ifndef SEQLIST_H


#define SEQLIST_H


/*定义链表节点指针类型*/
typedef struct node * link;


/*定义链表节点结构体*/
struct node {
unsigned long key;
void  * obj;
link pre;
link next;
};


/*向链表尾插入新节点
*参数1：链表头指针 
*参数2：新节点
*返回链表头指针
* */
link insert(link head,link node_p);

/*搜索指定值
*参数1：链表头指针
*参数2：查找的值
*返回找到的节点指针
* */
link search(link head,unsigned long key);


/*从链表中删除指定值的节点
*参数1：链接头指针
*参数2：删除节点的值
*返回链表头指针
* */
link delete(link head,unsigned long key);


#endif

#include <stdio.h>
#include <stdlib.h>
#include "SeqList.h"


link insert(link head,link node_p){
if(NULL==node_p) return head;
if(NULL==head) return node_p;
while(NULL!=head->next){
head=head->next;
}
head->next=node_p;
node_p->pre=head;
while(NULL!=head->pre){
head=head->pre;
}
return head;
}


link search(link head,unsigned long key){
link r=NULL;
r=head;
while(NULL!=r){
if(r->key==key){
break;
}
r=r->next;
}
return r;
}


link delete(link head,unsigned long key){
if(NULL==head) return NULL;
link r=head;
link pre=NULL;
link next=NULL;


do{
pre=r->pre;
next=r->next;
if(r->key==key){
if(NULL==pre){
pre=next;
}
else{
pre->next=next;
if(NULL!=next){
next->pre=pre;
}
}
free(r);
break;
}
r=r->next;

}while(NULL!=r);


while(NULL!=pre){
pre=pre->pre;
}
return pre;
}

#ifndef HASH_H

#define HASH_H


unsigned long  hash_len;


/*
* 初始化哈希表
* 参数：哈希表的长度
* 返回哈希表指针
* */
  void * init_hash(unsigned long len);


/*
* 向哈希表中添加数据
* 参数1：哈希表指针地址
* 参数2：键值
* 参数3：数据值指针
* */
void hash_add(void * hash,unsigned long key,void * val);


/*
* 从哈希表中移除数据
* 参数1：哈希表指针地址
* 参数2：键值
* */
void hash_remove(void * hash,unsigned long key);


/*
* 从哈希表中找查指定键值数据
* 参数1：哈希表指针地址
* 参数2：查询的键值
* 返回数据值指针
* */
void * hash_search(void * hash,unsigned long key);


/*
* 释放哈希表
* 参数：哈希表指针地址
* */
void hash_free(void * hash);

#endif

#include <stdio.h>
#include <stdlib.h>
#include "../SeqList/SeqList.h"
#include "Hash.h"


extern link insert(link head,link node_p);


extern link search(link head,unsigned long key);


extern link delete(link head,unsigned long key);




static unsigned long hash_long(unsigned long,unsigned int bits);


static unsigned long hash_long(unsigned long val,unsigned int bits){
unsigned long hash = val*0x9e370001UL;
return hash >> (32-bits);
}


void * init_hash(unsigned long len){
if(0==len) return NULL;
hash_len=len;
link *h =malloc(hash_len*sizeof(link));
return h;
}


void hash_add(void * hash,unsigned long key,void * val){
link *r=(link *)hash;
if(0==hash_len) return;

link _n=(link)hash_search(hash,key);
if(NULL!=_n){
printf("%d key value exists value:%d\n",key,_n->key);
return;
}

unsigned long h_key=hash_long(key,11) % hash_len;

if(h_key>hash_len-1){
printf("hash length overflow=> key:%d\n",key);
return;
}


link node=malloc(sizeof *node);
node->key=key;
node->obj=val;
node->pre=NULL;
node->next=NULL;


r[h_key]=insert(r[h_key],node);
}


void hash_remove(void * hash,unsigned long key){
link *r=(link *)hash;
if(NULL==r) return;
if(0==hash_len) return;
unsigned long h_key=hash_long(key,11) % hash_len;
if(h_key>hash_len-1){
printf("hash length overflow=> key:%d\n",key);
return;
}
if(NULL!=r[h_key]){
r[h_key]=delete(r[h_key],key);
}
}


void * hash_search(void * hash,unsigned long key){
link *r=(link *)hash;
if(NULL==r) return NULL;
if(0==hash_len) return NULL;
unsigned long h_key=hash_long(key,11) % hash_len;
if(h_key>hash_len-1){
printf("hash length overflow=> key:%d\n",key);
return NULL;
}
if(NULL==r[h_key]){
return NULL;
}
else{
printf("[%d]=%d \n",h_key,key);
link _r=search(r[h_key],key);
return _r;
}
}


void hash_free(void * hash){
if(0==hash_len) return;
link *r=(link *)hash;
if(NULL==r) return;


link c=NULL;
int i=0;
printf("before free-------------------\n");
for(i=0;i<hash_len;i++){
printf("%d addr= [%d] -> %d ",
r[i],i,NULL==r[i] ? 0 : r[i]->key);
if(NULL!=r[i]){
c=r[i];
while(NULL!=c->next){
c=c->next;
printf(" -> %d ",c->key);
}
}
printf("\n");
}
for(i=0;i<hash_len;i++){
c=r[i];
if(NULL!=c){
while(NULL!=c->next){
c=c->next;
free(c->pre);
}
free(c);
}
r[i]=NULL;
}
printf("afert free--------------------\n");
for(i=0;i<hash_len;i++){
printf("%d addr=[%d] -> %d\n",
r[i],i,NULL==r[i] ? 0 :r[i]->key);
}
c=NULL;
free(hash);
}