取余数法实现哈希表（包括开放定址法和链地址法解决冲突）

常用的构造散列函数的方法

　　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. 建立一个公共溢出区

#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");
    }
}

#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;
    }
}