hash 介绍及 代码

https://blog.csdn.net/asdzheng/article/details/70226007

https://blog.csdn.net/zeb_perfect/article/details/52574915

Hash碰撞冲突

我们知道，对象Hash的前提是实现equals()和hashCode()两个方法，那么HashCode()的作用就是保证对象返回唯一hash值，但当两个对象计算值一样时，这就发生了碰撞冲突。如下将介绍如何处理冲突，当然其前提是一致性hash。


1.开放地址法
开放地执法有一个公式: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取值可能为伪随机数列。称伪随机探测再散列。


2.再哈希法
当发生冲突时，使用第二个、第三个、哈希函数计算地址，直到无冲突时。缺点：计算时间增加。
比如上面第一次按照姓首字母进行哈希，如果产生冲突可以按照姓字母首字母第二位进行哈希，再冲突，第三位，直到不冲突为止


3.链地址法（拉链法）
将所有关键字为同义词的记录存储在同一线性链表中。如下：




因此这种方法，可以近似的认为是筒子里面套筒子


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


拉链法的优缺点：
优点：
①拉链法处理冲突简单，且无堆积现象，即非同义词决不会发生冲突，因此平均查找长度较短；
②由于拉链法中各链表上的结点空间是动态申请的，故它更适合于造表前无法确定表长的情况；
③开放定址法为减少冲突，要求装填因子α较小，故当结点规模较大时会浪费很多空间。而拉链法中可取α≥1，且结点较大时，拉链法中增加的指针域可忽略不计，因此节省空间；
④在用拉链法构造的散列表中，删除结点的操作易于实现。只要简单地删去链表上相应的结点即可。而对开放地址法构造的散列表，删除结点不能简单地将被删结 点的空间置为空，否则将截断在它之后填人散列表的同义词结点的查找路径。这是因为各种开放地址法中，空地址单元(即开放地址)都是查找失败的条件。因此在 用开放地址法处理冲突的散列表上执行删除操作，只能在被删结点上做删除标记，而不能真正删除结点。
缺点：
指针需要额外的空间，故当结点规模较小时，开放定址法较为节省空间，而若将节省的指针空间用来扩大散列表的规模，可使装填因子变小，这又减少了开放定址法中的冲突，从而提高平均查找速度。

文章转自：https://www.byvoid.com/blog/string-hash-compare

常用的字符串Hash函数还有ELFHash，APHash等等，都是十分简单有效的方法。这些函数使用位运算使得每一个字符都对最后的函数值产生影响。另外还有以MD5和SHA1为代表的杂凑函数，这些函数几乎不可能找到碰撞。

常用字符串哈希函数有BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash等等。对于以上几种哈希函数，我对其进行了一个小小的评测。

Hash函数	数据1	数据2	数据3	数据4	数据1得分	数据2得分	数据3得分	数据4得分	平均分
BKDRHash	2	0	4774	481	96.55	100	90.95	82.05	92.64
APHash	2	3	4754	493	96.55	88.46	100	51.28	86.28
DJBHash	2	2	4975	474	96.55	92.31	0	100	83.43
JSHash	1	4	4761	506	100	84.62	96.83	17.95	81.94
RSHash	1	0	4861	505	100	100	51.58	20.51	75.96
SDBMHash	3	2	4849	504	93.1	92.31	57.01	23.08	72.41
PJWHash	30	26	4878	513	0	0	43.89	0	21.95
ELFHash	30	26	4878	513	0	0	43.89	0	21.95
其中数据1为100000个字母和数字组成的随机串哈希冲突个数。数据2为100000个有意义的英文句子哈希冲突个数。数据3为数据1的哈希值与1000003(大素数)求模后存储到线性表中冲突的个数。数据4为数据1的哈希值与10000019(更大素数)求模后存储到线性表中冲突的个数。

经过比较，得出以上平均得分。平均数为平方平均数。可以发现，BKDRHash无论是在实际效果还是编码实现中，效果都是最突出的。APHash也是较为优秀的算法。DJBHash,JSHash,RSHash与SDBMHash各有千秋。PJWHash与ELFHash效果最差，但得分相似，其算法本质是相似的。

在信息修竞赛中，要本着易于编码调试的原则，个人认为BKDRHash是最适合记忆和使用的。

BYVoid原创，欢迎建议、交流、批评和指正。

附：各种哈希函数的C语言程序代码
unsigned int SDBMHash(char *str)
{
    unsigned int hash = 0;

    while (*str)
    {
        // equivalent to: hash = 65599*hash + (*str++);
        hash = (*str++) + (hash << 6) + (hash << 16) - hash;
    }

    return (hash & 0x7FFFFFFF);
}

// RS Hash Function
unsigned int RSHash(char *str)
{
    unsigned int b = 378551;
    unsigned int a = 63689;
    unsigned int hash = 0;

    while (*str)
    {
        hash = hash * a + (*str++);
        a *= b;
    }

    return (hash & 0x7FFFFFFF);
}

// JS Hash Function
unsigned int JSHash(char *str)
{
    unsigned int hash = 1315423911;

    while (*str)
    {
        hash ^= ((hash << 5) + (*str++) + (hash >> 2));
    }

    return (hash & 0x7FFFFFFF);
}

// P. J. Weinberger Hash Function
unsigned int PJWHash(char *str)
{
    unsigned int BitsInUnignedInt = (unsigned int)(sizeof(unsigned int) * 8);
    unsigned int ThreeQuarters    = (unsigned int)((BitsInUnignedInt  * 3) / 4);
    unsigned int OneEighth        = (unsigned int)(BitsInUnignedInt / 8);
    unsigned int HighBits         = (unsigned int)(0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);
    unsigned int hash             = 0;
    unsigned int test             = 0;

    while (*str)
    {
        hash = (hash << OneEighth) + (*str++);
        if ((test = hash & HighBits) != 0)
        {
            hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
        }
    }

    return (hash & 0x7FFFFFFF);
}

// ELF Hash Function
unsigned int ELFHash(char *str)
{
    unsigned int hash = 0;
    unsigned int x    = 0;

    while (*str)
    {
        hash = (hash << 4) + (*str++);
        if ((x = hash & 0xF0000000L) != 0)
        {
            hash ^= (x >> 24);
            hash &= ~x;
        }
    }

    return (hash & 0x7FFFFFFF);
}

// BKDR Hash Function
unsigned int BKDRHash(char *str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
    unsigned int hash = 0;

    while (*str)
    {
        hash = hash * seed + (*str++);
    }

    return (hash & 0x7FFFFFFF);
}

// DJB Hash Function
unsigned int DJBHash(char *str)
{
    unsigned int hash = 5381;

    while (*str)
    {
        hash += (hash << 5) + (*str++);
    }

    return (hash & 0x7FFFFFFF);
}

// AP Hash Function
unsigned int APHash(char *str)
{
    unsigned int hash = 0;
    int i;

    for (i=0; *str; i++)
    {
        if ((i & 1) == 0)
        {
            hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));
        }
        else
        {
            hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));
        }
    }

    return (hash & 0x7FFFFFFF);
}

#include <iostream>  
using namespace std;  
#define  MAXSIZE 10//哈希链表 数组个数 当然可以适当的增加或者减少  
  
/* 
注意点!!!  
1.key值一定不能重复的  
2.解决地址冲突法 本例用链表解决冲突即闭址法 
*/  
  
/* 
个人认为哈希表建表应当注意以下几个步骤: 
 
1.首先应当建立哈希函数 
2.建立初始化函数 
3.建立查找函数 至于为什么先建立这个函数是为了 下面的插入key值函数做准备的 因为判断条件要用到 
4.其它函数可以自己随意添加.... 
 
*/  
  
struct Node  
{  
    int nKey;//key 记住 一定不能重复 国内人大多忘记讲这些  
    int nCount;//key对应的 value 当然可以换成自己定义的数据类型  
    char cFlag;//状态 当前是否被占用  
    Node* pNext;//链表结构  
};  
struct hashTable//一般哈希表 都是这样的结构  
{  
    Node *pFirst;  
    int nCount;//当前共有多少个key  
  
  
};  
  
int hash(int nKey)//1. 最简单的哈希函数  
{  
    return nKey%MAXSIZE;//返回数组的索引  
}  
  
void createHash(hashTable&ht)//创建哈希表  
{  
    //因为是c语言写的 结构体不能初始化指针 所以判断条件改为0xcccccccc  
    if (ht.pFirst==(Node*)0xcccccccc)//防止同一个指针被多次创建  c语言指针初始化的时候默认是0xccccccc 大家可以调试一下  
    {  
        ht.pFirst=new Node[MAXSIZE];  
        ht.nCount=0;  
        for (int i=0;i<MAXSIZE;i++)//初始化  
        {  
            ht.pFirst[i].cFlag=0;  
            ht.pFirst[i].pNext=0;  
            ht.pFirst[i].nCount=0;  
  
  
        }  
    }   
      
  
}  
//这里指针直接用的引用 这样操作起来方便  
bool findKey(hashTable&ht,int nKey)//寻找key  
{  
  
    int nBuf=hash(nKey);//根据哈希表计算索引  
    Node* pBuf=0;  
    if (ht.pFirst[nBuf].nKey==nKey)//查找一般分为两部分 如果数组里面 没有 那么就取链表里面查找  
    {  
        return true;  
    }   
    else//查找该数组对应的链表  
    {  
        pBuf=ht.pFirst[nBuf].pNext;  
        while (pBuf)  
        {  
            if (pBuf->nKey==nKey)  
            {  
                return true;  
            }   
              
            pBuf=pBuf->pNext;  
        }  
    }  
    return false;//没查到  
}  
void insertKey(hashTable&ht,int nKey)//插入key  
{  
    int nBuf=hash(nKey);  
    Node* pBuf=0;  
    if (findKey(ht,nKey))//如果已经存在该 key了 那么直接返回 因为 key肯定不能重复!!!  
    {  
        return;  
    }   
    if (ht.pFirst[nBuf].cFlag==0)//如果数组里面还没插入 此时没有冲突 那么直接插入到数组里面即可  
    {  
        ht.pFirst[nBuf].nKey=nKey;  
        ht.pFirst[nBuf].cFlag=1;//标记状态已经被占用了  
          
    }   
    else//数组里面已经有了 所以用链表解决地址冲突法  
    {  
        pBuf=new Node;//这里的链表采用的是前段插入方式 这样就只需要维护一个头结点即可  
        pBuf->nKey=nKey;  
        pBuf->cFlag=1;//状态已经被用了  
        pBuf->pNext=ht.pFirst[nBuf].pNext;//前端插入  
        ht.pFirst[nBuf].pNext=pBuf;//前段插入  
    }  
    ht.nCount++;  
      
  
}  
  
void showAll(hashTable&ht)//全部显示出来方便观察  
{  
    int nBuf=0;  
    Node* pBuf=0;  
    for (int i=0;i<MAXSIZE;i++)//先遍历数组  
    {  
        cout<<"数组值:"<<ht.pFirst[i].nKey<<""<<"链表值 :";  
        pBuf=ht.pFirst[i].pNext;  
        while (pBuf)//遍历链表  
        {  
            cout<<""<<pBuf->nKey<<" ";  
            pBuf=pBuf->pNext;  
        }  
        cout<<endl;  
    }  
  
    cout<<"一共有:"<<ht.nCount<<"个key值"<<endl;  
}  
void main()  
{  
  
    hashTable ht;  
　　ht.pFirst==(Node*)0xcccccccc  
  
    createHash(ht);//初始化  
      
    for (int i=0;i<100;i++)  
    {  
        insertKey(ht,i);//插入key 注意key不能重复!!!!  
    }  
    showAll(ht);  
      
}