Algorithm Design——Hash表

/**
哈希表的几个概念：
映像：由哈希函数得到的哈希表是一个映像。
冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。

处理冲突的几个方法：
1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。
例如：hash(i)=(hash(key)+d(i)) MOD m (i=1,2,3,......,k(k<m-1)) d为增量函数，d(i)=d1,d2,d3,...,dn-1
根据增量序列的取法不同，可以得到不同的开放地址处理冲突探测方法。
有线性探测法、二次方探测法、伪随机探测法。
2、链地址法：把所有关键字为同义词的记录存储在一个线性链表中，这个链表成为同义词链表，即把具有相同哈希地址的关键字值存放在同义链表中。
3、再哈希表：费时间的一种方法
*/

#include<iostream>  
using namespace std;  

typedef int KeyType; //设关键字域为整形,需要修改类型时，只需修改这里就可以  
const int NULLKEY=0; //NULLKEY表示该位置无值  
int c=0; //用来统计冲突次数  

struct Elemtype //数据元素类型  
{  
    KeyType key;  
    int ord;   
};  

int hashsize[]={11,19,29,37,47}; //hash表容量递增表  
int Hash_length=0;//hash表表长  

class HashTable  
{  
private:  
    Elemtype *elem; //数据元素数组,动态申请  
    int count;// 当前数据元素个数  
    int size; //决定hash表的容量为第几个,hashsize[size]为当前hash容量  
public:  

    int Init_HashTable() //构造一个空hash表  
    {  
        int i;  
        count=0;  
        size=0; //初始化容量为hashsize[0]=11  
        Hash_length=hashsize[0];  
        elem=new Elemtype[Hash_length];  
        if(!elem)  
        {  
            cout<<"内存申请失败"<<endl;  
            exit(0);  
        }  
        for(i=0;i<Hash_length;i++)  
            elem[i].key=NULLKEY;  
        return 1;  
    }  

    void Destroy_HashTable()  
    {  
        delete[]elem;  
        elem=NULL;  
        count=0;  
        size=0;  
    }  

    unsigned Hash(KeyType k) //hash函数的一种(取模法)  
    {  
        return k%Hash_length;  
    }  

    void Collision(int &p,int d) //解决冲突  
    {  
        p=(p+d)%Hash_length; //采用开放地址法里的线性探测  
    }  

    bool Search_Hash(KeyType k,int &p) //查找  
    {  
        //在开放地址hash表中查找关键字等于k的元素  
        //若找到用p表示待查数据,查找不成功时，p指向的是可插入地址  
        c=0;  
        p=Hash(k); //求hash地址  
        while(elem[p].key!=NULLKEY && elem[p].key!=k)  
        {  
            c++;  
            if(c<Hash_length)  
                Collision(p,c);  
            else  
                return 0; //表示查找不成功  
        }  
        if(elem[p].key==k)  
            return 1;  
        else  
            return 0;  

    }  

    int Insert_Hash(Elemtype e) //插入  
    {  
        //在查找不成功的情况下将k插入到hash表中  
        int p;  
        if(Search_Hash(e.key,p))  
            return -1; //表示该元素已在hash表中  
        else if(c<hashsize[size]/2) //冲突次数未达到上限  
        {  
            //插入e  
            elem[p]=e;  
            count++;  
            return 1;  
        }  
        else  
            ReCreate_HashTable(); // 重建hash表  
        return 0; //插入失败  
    }  

    void ReCreate_HashTable() //重建hash表  
    {  
        int i,count2=count;  
        Elemtype *p,*elem2=new Elemtype[count];  
        p=elem2;  
        cout<<"____重建hash表_____"<<endl;  
        for(i=0;i<Hash_length;i++) //将原有元素暂存到elem2中  
            if(elem[i].key!=NULLKEY)  
                *p++=*(elem+i);  
        count=0;delete []elem;  
        size++; //hash容量增大  
        Hash_length=hashsize[size];  
        p=new Elemtype[Hash_length];  
        if(!p)  
        {  
            cout<<"空间申请失败"<<endl;  
            exit(0);  
        }  
        elem=p;  
        for(i=0;i<Hash_length;i++)  
            elem[i].key=NULLKEY;  
        for(p=elem2;p<elem2+count2;p++) //将原有元素放回新表  
            Insert_Hash(*p);  
    }  

    void Traverse_HashTable()  
    {  
        cout<<"哈希地址0->"<<Hash_length-1<<endl;  
        for(int i=0;i<Hash_length;i++)  
            if(elem[i].key!=NULLKEY)  
                cout<<"元素的关键字值和它的标志分别是："<<elem[i].key<<"  "<<elem[i].ord<<endl;  

    }  

    void Get_Data(int p)  
    {  
        cout<<"元素的关键字值和它的标志分别是："<<elem[p].key<<"  "<<elem[p].ord<<endl;  
    }  

};  

int main()  
{  
    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}};  
    HashTable H;  
    int i,p,j;  
    KeyType k;  
    H.Init_HashTable();  
    for(i=0;i<11;i++) //插入前11个记录  
    {  
        j=H.Insert_Hash(r[i]);  
        if(j==-1)  
            cout<<"表中已有关键字为"<<r[i].key<<"  "<<r[i].ord<<"的记录"<<endl;  
    }  

    cout<<"按哈希地址顺序遍历哈希表"<<endl;  
    H.Traverse_HashTable();  
    cout<<endl;  

    cout<<"输入要查找的记录的关键字：";  
    cin>>k;  
    j=H.Search_Hash(k,p);  
    if(j==1)  
        H.Get_Data(p);  
    else  
        cout<<"无此记录"<<endl;  

    j=H.Insert_Hash(r[11]); //插入最后一个元素  
    if(j==0)  
    {  
        cout<<"插入失败"<<endl;  
        cout<<"需要重建哈希表才可以插入"<<endl;  
        cout<<"____重建哈希表____"<<endl;  
        H.Insert_Hash(r[i]); //重建后重新插入  
    }  

    cout<<"遍历重建后的哈希表"<<endl;  
    H.Traverse_HashTable();  
    cout<<endl;  

    cout<<"输入要查找的记录的关键字：";  
    cin>>k;  
    j=H.Search_Hash(k,p);  
    if(j==1)  
        H.Get_Data(p);  
    else  
        cout<<"该记录不存在"<<endl;  

    cout<<"____销毁哈希表____"<<endl;  
    H.Destroy_HashTable();  

    return 0;  
}

/**Hash实例一：
题目描述： 读入N名学生的成绩，将获得某一给定分数的学生人数输出。

输入：
测试输入包含若干测试用例，每个测试用例的格式为 
第1行：N 
第2行：N名学生的成绩，相邻两数字用一个空格间隔。 
第3行：给定分数 
当读到N=0时输入结束。其中N不超过1000，成绩分数为（包含）0到100
之间的一个整数。 

输出：
对每个测试用例，将获得给定分数的学生人数输出。

样例输入： 
3
80 60 90 
60 
2
85 66 
0 
5
60 75 90 55 75 
75 
0

样例输出： 
1 
0 
2
*/

#include<cstdio>

int main()
{
    int n;
    while(scanf_s("%d", &n) != EOF && n != 0)
    {
        int Hash[101] = {0};//建立一个初始为0的Hash数组用来记录各种分数出现的次数
        for(int i = 1 ; i <= n ; i ++)
        {
            int x;
            scanf_s("%d", &x);
            Hash[x] ++;//统计分数出现次数
        }

        int aim;
        scanf_s("%d", &aim);
        printf_s("%d", Hash[aim]);//得到目标分数后，只需简单查询我们统计的数量即可
    }
}

/**Hash实例二：
题目描述： 给你n个整数，请按从大到小的顺序输出其中前m大的数。

输入： 
每组测试数据有两行，第一行有两个数n,m(0<n,m<1000000)，第二行包含n
个各不相同，且都处于区间[-500000,500000]的整数。

输出：
对每组测试数据按从大到小的顺序输出前m大的数。

样例输入： 
5 3
3 -35 92 213 -644 

样例输出：
213 92 3
*/

#include<cstdio>

#define OFFSET 500000

int Hash[1000001];

int main()
{
    int n, m;
    while(scanf_s("%d%d", &n, &m) != EOF)
    {
        for(int i = -500000 ; i <= 500000 ; i ++)
        {
            Hash[i + OFFSET] = 0;//初始化
        }

        for(int i = 1 ; i <= n ; i ++)
        {
            int x;
            scanf_s("%d", &x);
            Hash[x + 500000] = 1;//凡是出现过的数字，该数组元素均被设置成1
        }

        for(int i = 500000 ; i >= -500000 ; i --)
        {
            if(Hash[i + OFFSET] == 1)
            {
                printf_s("%d", i);
                m --;
                if(m !=0)
                    printf_s(" ");
                else
                {
                    printf_s("
");
                    break;
                }
            }
        }
    }
    return 0;
}