常用的构造散列函数的方法
1. 直接寻址法:取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a·key + b,其中a和b为常数(这种散列函数叫做自身函数)。若其中H(key)中已经有值了,就往下一个找,直到H(key)中没有值了,就放进去。
2. 数字分析法:分析一组数据,比如一组员工的出生年月日,这时我们发现出生年月日的前几位数字大体相同,这样的话,出现冲突的几率就会很大,但是我们发现年月日的后几位表示月份和具体日期的数字差别很大,如果用后面的数字来构成散列地址,则冲突的几率会明显降低。因此数字分析法就是找出数字的规律,尽可能利用这些数据来构造冲突几率较低的散列地址。
3. 平方取中法:取关键字平方后的中间几位作为散列地址。
4. 折叠法:将关键字分割成位数相同的几部分,最后一部分位数可以不同,然后取这几部分的叠加和(去除进位)作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐,然后相加;间界叠加是从一端向另一端沿分割界来回折叠,然后对齐相加。
5. 随机数法:选择一随机函数,取关键字的随机值作为散列地址,通常用于关键字长度不同的场合。
6. 除留余数法:取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p,p<=m。不仅可以对关键字直接取模,也可在折叠、平方取中等运算之后取模。对p的选择很重要,一般取素数或m,若p选的不好,容易产生同义词。
处理冲突的方法
1. 开放寻址法:Hi=(H(key) + di) MOD m,i=1,2,…,k(k<=m-1),其中H(key)为散列函数,m为散列表长,di为增量序列,可有下列三种取法:
1.1. di=1,2,3,…,m-1,称线性探测再散列;
1.2. di=1^2,-1^2,2^2,-2^2,⑶^2,…,±(k)^2,(k<=m/2)称二次探测再散列;
1.3. di=伪随机数序列,称伪随机探测再散列。
2. 再散列法:Hi=RHi(key),i=1,2,…,k RHi均是不同的散列函数,即在同义词产生地址冲突时计算另一个散列函数地址,直到冲突不再发生,这种方法不易产生“聚集”,但增加了计算时间。
3. 链地址法(拉链法)
4. 建立一个公共溢出区
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#include <iostream> #define NULLKEY 0//0为无记录标志 #define SUCCESS 1 #define UNSUCCESS 0 #define DUPLICATE -1 using namespace std; int hashsize[]={11,19,29,37};//哈希表容量递增表(一个合适的素数序列) int Hash_length=0;//哈希表表长 //定义记录 struct ElemType{ int key_value; float weight; }; //定义哈希表 struct HashTable{ ElemType *elem;//数据元素存储基址(动态分配数组) int count;//当前数据元素个数 int size_index;//hashsize[size_index]为当前容量 }; //初始化哈希表 int InitHashTable(HashTable &ht){ ht.count=0; ht.size_index=0; Hash_length=hashsize[ht.size_index];//表长为全局变量 ht.elem=(ElemType*)malloc(Hash_length*sizeof(ElemType)); if(!ht.elem) exit(1); for(int i=0;i<Hash_length;i++){ht.elem[i].key_value=NULLKEY;}//方便后面判断对应位置是否被占用 return 1; } //销毁哈希表。 //初始条件:哈希表ht存在;操作结果:销毁哈希表ht void DestroyHashTable(HashTable &ht) { if(ht.elem != NULL) free(ht.elem); ht.elem=0; ht.count=0; ht.size_index=0; } //一个简单的哈希函数,其中Hash_length为表长 int Hash(int K) { return K%Hash_length;//key MOD p(其中p<=Hash_length) } //开放定址法处理冲突,Hash_length为表长,线性探测再散列 int collision(int H_key,int d) { return (H_key+d)%Hash_length; } //在开放定址哈希表H中查找关键码为K的元素, //若查找成功,以p指示待查数据元素在表中位置,并返回SUCCESS; //否则,以p指示插入位置,并返回UNSUCCESS。 //注意:c用以计冲突次数,其初值置零,供建表插入时参考 int SearchHash(HashTable ht, int key, int &p, int &c){ p=Hash(key); int p_original=p; c = 0; while(c<hashsize[ht.size_index] && ht.elem[p].key_value!=NULLKEY && ht.elem[p].key_value!=key){ c++; p=collision(p_original,c); } if(ht.elem[p].key_value==key) return SUCCESS; else return UNSUCCESS; } //删除元素 int DeleteElem(HashTable ht, int key){ int p, c=0; if (SearchHash(ht, key, p, c)==SUCCESS){ ht.elem[p].key_value=NULLKEY; ht.count--; return SUCCESS; } else{ return UNSUCCESS; } } void RecreateHashTable(HashTable &ht); //查找不成功时插入数据元素e到开放定址哈希表ht中,并返回1,若冲突次数过大,则重建哈希表 int InsertHash(HashTable &ht, ElemType e){ int p, c=0; if(SearchHash(ht, e.key_value, p, c)==SUCCESS){//已经存在e return DUPLICATE; } else if(c<hashsize[ht.size_index]/2){//不存在e,冲突次数c未达到上限hashsize[ht.size_index]/2 ht.elem[p]=e; ht.count++; return SUCCESS; } else {//不存在e,冲突次数c达到上限 RecreateHashTable(ht);//重建新的哈希表ht,ht的容量以及元素的位置发生变化 InsertHash(ht, e);//将元素插入 return SUCCESS; } } void RecreateHashTable(HashTable &ht)//重建哈希表 { printf("冲突次数达到上限,增大表长,重建哈希表。。。\n"); ElemType* p_tmp=ht.elem;//暂存 int size_index_tmp=ht.size_index;//暂存 //增大存储容量,给ht.elem重新分配空间 ht.count=0; ht.size_index++; Hash_length=hashsize[ht.size_index];//更新Hash_length ElemType* p_new=(ElemType*)malloc(Hash_length*sizeof(ElemType)); if(!p_new) exit(1); ht.elem=p_new; //初始化 for(int i=0;i<Hash_length;i++) ht.elem[i].key_value=NULLKEY; //将tmp中的原有的数据按照新的表长插入到重建的哈希表中 for(int i=0;i<hashsize[size_index_tmp];i++){ if((p_tmp+i)->key_value!=NULLKEY){ InsertHash(ht,*(p_tmp+i)); } } delete[] p_tmp; printf("重建哈希表成功!\n"); } /* 按哈希地址的顺序遍历哈希表 */ void TraverseHash(HashTable ht,void(*Visit)(int, ElemType)){ printf("哈希地址:0~%d\n",Hash_length-1); for(int i=0;i<Hash_length;i++){ if(ht.elem[i].key_value!=NULLKEY) Visit(i,ht.elem[i]); } } void main(){ while(1){ //ElemType r[12]={{17,1},{60,2},{29,3},{38,4},{1,5},{2,6},{3,7},{4,8},{5,9},{6,10},{7,11},{8,12}}; ElemType r[12]={{17,1},{60,2},{29,3},{38,4},{1,5},{2,6},{3,7},{4,8},{5,9},{6,10},{60,9},{13,10}}; HashTable h; InitHashTable(h); cout<<"向哈希表中插入记录。。。"<<endl; for(int i=0;i<sizeof(r)/sizeof(r[0]);i++){ if(InsertHash(h,r[i]) == DUPLICATE){ cout<<"表中已有关键字"<<r[i].key_value<<"的记录,无法再插入该记录!"<<endl; cout<<"继续插入后续元素。。。"<<endl; } } printf("按哈希地址的顺序遍历哈希表:\n"); TraverseHash(h,Print_Hash); DeleteElem(h,29); printf("按哈希地址的顺序遍历哈希表:\n"); TraverseHash(h,Print_Hash); printf("销毁哈希表。。。\n"); DestroyHashTable(h); system("pause"); } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#include <iostream> #define HASH_LENGTH 13 #define NULLKEY 0//0为无记录标志 using namespace std; //定义记录 struct ElemType1{ int key_value; float weight; }; //定义每个子链的结点 struct Node{ ElemType1 elem; struct Node *next; }; //定义哈希表的结点 struct HashTable_Node{ int h_value;//除取余数得到的哈希值 struct Node *pointer;//每个子链的首地址 }; //定义链地址法的哈希表 typedef HashTable_Node* HashTable_L; //一个简单的哈希函数,其中HASH_LENGTH为表长 int Hash1(int K) { return K%HASH_LENGTH;//key MOD p(其中p<=HASH_LENGTH) } void Hash_Init(HashTable_L &ht){//哈希表初始化 ht=new HashTable_Node[HASH_LENGTH]; if (!ht) exit(1); for(int i = 0; i < HASH_LENGTH; i++){ ht[i].h_value=NULLKEY;//方便插入和查找 ht[i].pointer=NULL; } } void Hash_Insert(HashTable_L &ht, ElemType1 e){ int p=Hash1(e.key_value); Node* node=new Node(); if (!node) exit(1); node->elem=e; node->next=NULL; if(ht[p].h_value == NULLKEY){//对应该哈希值的子链为空 ht[p].pointer=node; ht[p].h_value=p; } else if(ht[p].h_value == p){//对应该哈希值的子链不为空 Node* ptr=ht[p].pointer; while(ptr->next){ptr=ptr->next;} ptr->next=node; } } Node* Hash_Search(HashTable_L ht, int key){ int p=Hash1(key); if(ht[p].h_value == NULLKEY)//对应该哈希值的子链为空 return NULL; else if(ht[p].h_value == p){//对应该哈希值的子链不为空 Node* ptr=ht[p].pointer; while(ptr != NULL){ if(ptr->elem.key_value == key){ return ptr; } ptr=ptr->next; } } else return NULL; } void main(){ ElemType1 r[13]={{17,1},{60,2},{29,3},{38,4},{1,5},{2,6},{60,2},{3,7},{4,8},{5,9},{6,10},{7,11},{8,12}}; //ElemType1 r[13]={{17,1},{60,2},{29,3},{38,4},{1,5},{2,6},{3,7},{4,8},{5,9},{6,10},{7,11},{8,12}}; HashTable_L ht=NULL; Hash_Init(ht); for(int i=0;i<sizeof(r)/sizeof(r[0]);i++){ Hash_Insert(ht, r[i]); } while (1) { int key; cout<<"请输入关键字(key):"; cin>>key; Node *p=NULL; if(p=Hash_Search(ht, key)) cout<<"哈希值与关键字的值分别为:"<<Hash1(key)<<" "<<p->elem.key_value<<endl; else cout<<"无匹配!"<<endl; } }