查找----深入探索散列查找

最新推荐文章于 2022-08-04 10:42:05 发布

eastlhu

最新推荐文章于 2022-08-04 10:42:05 发布

阅读量575

点赞数

分类专栏：算法设计

算法设计专栏收录该内容

48 篇文章 1 订阅

订阅专栏

1、散列函数

把任意长的输入消息串变化成固定长的输出串的一种函数。这个输出串称为该消息的杂凑值。一般用于产生消息摘要，密钥加密等。常见的散列函数构造方法如下：

（1）直接定址法

　例如：有一个从1到100岁的人口数字统计表，其中，年龄作为关键字，哈希函数取关键字自身。

（2）数字分析法

　　有学生的生日数据如下：

　　年.月.日

　　75.10.03

　　75.11.23

　　76.03.02

　　76.07.12

　　75.04.21

　　76.02.15

　...

　　经分析，第一位，第二位，第三位重复的可能性大，取这三位造成冲突的机会增加，所以尽量不取前三位，取后三位比较好。

（3）平方取中法

　　取关键字平方后的中间几位为哈希地址。

（4）折叠法

　　将关键字分割成位数相同的几部分（最后一部分的位数可以不同），然后取这几部分的叠加和（舍去进位）作为哈希地址，这方法称为折叠法。

　　例如：每一种西文图书都有一个国际标准图书编号，它是一个10位的十进制数字，若要以它作关键字建立一个哈希表，当馆藏书种类不到10,000时，可采用此法构造一个四位数的哈希函数。

（5）除留取余法

　　取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址。 H(key)=key MOD p (p<=m)

（6）随机数法

　　选择一个随机函数，取关键字的随机函数值为它的哈希地址，即 H(key)=random(key），其中random为随机函数。通常用于关键字长度不等时采用此法。

　　若已知哈希函数及冲突处理方法，哈希表的建立步骤如下：

　　Step1.　取出一个数据元素的关键字key，计算其则哈希表中的存储地址D=H(key）。若存储地址为D的存储空间还没有被占用，则将该数据元素存入；否则发生冲突，执行Step2。

　　Step2.　根据规定的冲突处理方法，计算关键字为key的数据元素之下一个存储地址。若该存储地址的存储空间没有被占用，则存入；否则继续执行Step2，直到找出一个存储空间没有被占用的存储地址为止。

2、冲突处理

无论哈希函数设计有多么精细，都会产生冲突现象，也就是2个关键字处理函数的结果映射在了同一位置上，因此，有一些方法可以避免冲突。

（1）拉链法

　　拉出一个动态链表代替静态顺序存储结构，可以避免哈希函数的冲突，不过缺点就是链表的设计过于麻烦，增加了编程复杂度，会带来查找时需要遍历单链表的性能损耗。但是此法可以完全避免哈希函数的冲突。

（2）再散列法

　　设计二种甚至多种哈希函数，每当发生散列地址冲突时，就换一个散列函数计算，相信总有一个可以避免冲突。但是冲突几率还是有的，函数设计的越好或越多都可以将几率降到最低（除非人品太差，否则几乎不可能冲突）。

（3）线性探测法法

　　线性探测法有一个公式：Hi=(H(key)+di) MOD m i=1,2,...,k(k<=m-1）。其中，m为哈希表的表长。di 是产生冲突的时候的增量序列。

如果di值可能为1,2,3,...m-1，称线性探测法。如果di取1，则每次冲突之后，向后移动1个位置。

如果di取值可能为1,-1,2,-2,4,-4,9,-9,16,-16,...k*k,-k*k(k<=m/2）。称二次探测法。

如果di取值可能为伪随机数列（如果我们设置随机种子相同，则不断调用随机函数可以生成不会重复的序列，我们在查找时用同样的随机种子，则它每次得到的数列是相同的）。称伪随机探测法。

（4）建域法

假设哈希函数的值域为[0,m-1]，则设向量HashTable[0..m-1]为基本表，另外设立存储空间向量OverTable[0..v]用以存储发生冲突的记录。

    #define MAX 10  
              
    //链表数据结构  
    typedef struct list    
    {  
        int data;  
        list *next;  
    }*pList;  
      
    list hashtable[MAX];  ///链式法解决地址冲突，MAX个带头节点的hash链表  
      
    //除留取余法  
    int hashFunc(int n)     
    {  
        return n%MAX;  
    }  
      
    //创建hash链表  
    void createhash(int *array,int n)    
    {  
        pList p,pNew;  
        for (int i=0;i<n;i++)  
        {  
            pNew=new list;  
            pNew->data=array[i];  
            pNew->next=NULL;  
              
            int pos=hashFunc(array[i]);  
            p=hashtable[pos].next;  
              
            if (p!=NULL)         //将新的节点插入到头结点的后面  
            {  
                pNew->next=p;  
                hashtable[pos].next=pNew;  
            }   
            else  
            {  
                hashtable[pos].next=pNew;  
            }  
        }  
    }  
      
    //hash查找  
    bool SearchHash(int val)     
    {  
        int pos=hashFunc(val);        //找出在哪个hash链表  
        pList p=hashtable[pos].next;  //遍历对应的链表  
        while(p!=NULL)  
        {  
            if(p->data==val)  
                return true;  
            p=p->next;  
        }  
          
        return false;  
    }  
      
    //遍历hashtable  
    void TraverseHashtable()  
    {  
        for (int m=0;m<MAX;m++) //一次遍历每个链表里面的内容  
        {  
            pList p1=hashtable[m].next;  
            while(p1!=NULL)  
            {  
                cout<<p1->data<<" ";  
                p1=p1->next;  
            }  
        }  
        cout<<endl;  
    }