Hash

      Hashing 定义了一种将 字符 组成的 字符串 转换为固定长度 ( 一般是更短长度 ) 的数值或索引值的方法，称为散列法，也叫哈希法。由于通过更短的哈希值比用原始值进行数据库搜索更快，这种方法一般用来在数据库中建立索引并进行搜索，同时还用在各种解密算法中。
       设所有可能出现的关键字集合记为 U( 简称全集 ) 。实际发生 ( 即实际存储 ) 的关键字集合记为 K （ |K| 比 |U| 小得多）。 |K| 是集合 K 中元素的个数 。
       散列方法是使用函数 hash 将 U 映射到表 T[0..m-1] 的下标上（ m=O(|U|) ）。这样以 U 中关键字为自变量，以 h 为函数的运算结果就是相应结点的存储地址。从而达到在 O(1) 时间内就可完成查找。
其中：
① hash ： U → {0 ， 1 ， 2 ， … ， m-1} ，通常称 h 为散列函数 (Hash Function) 。散列函数 h 的作用是压缩待处理的下标范围，使待处理的 |U| 个值减少到 m 个值，从而降低空间开销。
② T 为散列表 (Hash Table) 。
③ hash(K _i )(K_i ∈ U) 是关键字为 K_i 结点存储地址 ( 亦称散列值或散列地址 ) 。
④ 将结点按其关键字的散列地址存储到散列表中的过程称为散列 (Hashing).
比如：有一组数据包括用户名字、电话、住址等，为了快速的检索，我们可以利用名字作为关键码， hash 规则就是把名字中每一个字的拼音的第一个字母拿出来，把该字母在 26 个字母中的顺序值取出来加在一块作为改记录的地址。比如张三，就是 Z+S ＝ 26+19 ＝ 45 。就是把张三存在地址为 45 处。
        但是这样存在一个问题，比如假如有个用户名字叫做：周四，那么计算它的地址时也是 Z+S ＝ 45 ，这样它与张三就有相同的地址，这就是冲突，也叫作碰撞！
        冲突：两个不同的关键字，由于散列函数值相同，因而被映射到同一表位置上。该现象称为冲突 (Collision) 或碰撞。发生冲突的两个关键字称为该散列函数的同义词 (Synonym) 。
        冲突基本上不可避免的，除非数据很少，我们只能采取措施尽量避免冲突，或者寻找解决冲突的办法。影响冲突的因素
    　冲突的频繁程度除了与 h 相关外，还与表的填满程度相关。
    　设 m 和 n 分别表示表长和表中填人的结点数，则将 α=n/m 定义为散列表的装填因子 (Load Factor) 。 α 越大，表越满，冲突的机会也越大。通常取 α≤1 。

----散列函数的构造方法：----
1、散列函数的选择有两条标准：简单和均匀。
    　简单指散列函数的计算简单快速；
    　均匀指对于关键字集合中的任一关键字，散列函数能以等概率将其映射到表空间的任何一个位置上。也就是说，散列函数能将子集 K 随机均匀地分布在表的地址集 {0 ， 1 ， … ， m-1} 上，以使冲突最小化。
2、常用散列函数
（ 1 ）直接定址法：比如在一个 0 ～ 100 岁的年龄统计表，我们就可以把年龄作为地址。
（ 2 ）平方取中法
具体方法：先通过求关键字的平方值扩大相近数的差别，然后根据表长度取中间的几位数作为散列函数值。又因为一个乘积的中间几位数和乘数的每一位都相关，所以由此产生的散列地址较为均匀。
（ 3 ）除留余数法
取关键字被某个不大于哈希表表长 m 的数 p 除后所得余数为哈希地址。
该方法的关键是选取 m 。选取的 m 应使得散列函数值尽可能与关键字的各位相关。 m 最好为素数
（ 4 ）随机数法
选择一个随机函数，取关键字的随机函数值为它的散列地址，即 h(key)=random(key)
其中 random 为伪随机函数，但要保证函数值是在 0 到 m-1 之间。

----处理冲突的方法：----
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,2,-2,4,-4,9,-9,16,-16,...k*k,-k*k(k<=m/2)
称二次探测再散列。
如果 di 取值可能为伪随机数列。称伪随机探测再散列。
开放地址法堆装填因子的要求
开放定址法要求散列表的装填因子 α≤l ，实用中取 α 为 0.5 到 0.9 之间的某个值为宜。
2、二次探查法(Quadratic Probing)
二次探查法的探查序列是：
h_i=(h(key)+i*i) ％ m 0≤i≤m-1 // 即 d_i=i²
即探查序列为 d=h(key) ， d+1² ， d+2² ， … ，等。
该方法的缺陷是不易探查到整个散列空间。
3、双重散列法(Double Hashing)
该方法是开放定址法中最好的方法之一，它的探查序列是：
h_i=(h(key)+i*h1(key)) ％ m 0≤i≤m-1 // 即 d_i=i*h1(key)
即探查序列为：
d=h(key) ， (d+h1(key)) ％ m ， (d+2h1(key)) ％ m ， … ，等。
该方法使用了两个散列函数 h(key) 和 h1(key) ，故也称为双散列函数探查法。
3 、拉链法
拉链法解决冲突的做法是：将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为 m ，则可将散列表定义为一个由 m 个头指针组成的指针数组 T[0..m-1] 。凡是散列地址为 i 的结点，均插入到以 T[i] 为头指针的单链表中。 T 中各分量的初值均应为空指针。在拉链法中，装填因子 α 可以大于 1 ，但一般均取 α≤1 。
4 、建立一个公共溢出区
假设哈希函数的值域为 [0,m-1], 则设向量 HashTable[0..m-1] 为基本表，另外设立存储空间向量 OverTable[0..v] 用以存储发生冲突的记录。

----性能分析----
    　插入和删除的时间均取决于查找，故下面只分析查找操作的时间性能。
    　虽然散列表在关键字和存储位置之间建立了对应关系，理想情况是无须关键字的比较就可找到待查关键字。但是由于冲突的存在，散列表的查找过程仍是一个和关键字比较的过程，不过散列表的平均查找长度比顺序查找、二分查找等完全依赖于关键字比较的查找要小得多。
（ 1 ）查找成功的 ASL
散列表上的查找优于顺序查找和二分查找。
（ 2 ） 查找不成功的 ASL
对于不成功的查找，顺序查找和二分查找所需进行的关键字比较次数仅取决于表长，而散列查找所需进行的关键字比较次数和待查结点有关。因此，在等概率情况下，也可将散列表在查找不成功时的平均查找长度，定义为查找不成功时对关键字需要执行的平均比较次数。
注意：
① 由同一个散列函数、不同的解决冲突方法构造的散列表，其平均查找长度是不相同的。
② 散列表的平均查找长度不是结点个数 n 的函数，而是装填因子 α 的函数。因此在设计散列表时可选择 α 以控制散列表的平均查找长度。
③ α 的取值
  α 越小，产生冲突的机会就小，但 α 过小，空间的浪费就过多。只要 α 选择合适，散列表上的平均查找长度就是一个常数，即散列表上查找的平均时间为 O(1) 。
④ 散列法与其他查找方法的区别
除散列法外，其他查找方法有共同特征为：均是建立在比较关键字的基础上。其中顺序查找是对无序集合的查找，每次关键字的比较结果为 "=" 或 "!=" 两种可能，其平均时间为 O(n) ；其余的查找均是对有序集合的查找，每次关键字的比较有 "=" 、 "<" 和 ">" 三种可能，且每次比较后均能缩小下次的查找范围，故查找速度更快，其平均时间为 O(lgn) 。而散列法是根据关键字直接求出地址的查找方法，其查找的期望时间为 O(1) 。

例子：
选取哈希函数 H(K)=(3K)%11, 用线性探测再散列法处理冲突。
试在 0 ～ 10 的散列地址空间中，对关键序列 22,41,53,46,30,13,01,67 构造哈希表，并求等概率情况下查找不成功的平均查找长度 ASL 。

/**//*--------------------------------------------------------
 *    hashtable.cpp
 *    Describe : example for hashing
 *    author   : JackRain
 *    date     : 08-13-2005
 *    E_mail   :  [email protected]
 *    Test with C-Free3.5
---------------------------------------------------------*/

#include <iostream>

#define addr_scope 11
int hash(int key)
{
    return(key*3)%11;
}
typedef int KeyType,DataType,Status;
//typedef int DataType;
//typedef int Status;
typedef struct {
     KeyType key;
 //    DataType data;
     Status   stat;   //1 = over; 0
}Element;

class HashTable
{
    public:
            HashTable(int n);
            ~HashTable();
            bool insert(int e);
            bool search(int e, int *pos);
            void display();
    private:
            Element *elem;
            int     hash_size;
            int     dataNum;
};
HashTable::HashTable(int n):hash_size(n),dataNum(0)
{
  //  hash_size = n;
   // dataNum = 0;
    elem = new Element[n];
    for(int i=0;i < n;i++)
     {
        elem[i].key = 0;
        elem[i].stat = 0;
    }
}

HashTable::~HashTable()
{
    delete[] elem;
}

bool HashTable::insert(int e)
{
    if(dataNum == hash_size)
     {
        cout<<"OverFlow!"<<endl;
        return false;
    }
    int pos = hash(e),pos1;
      pos1 = pos;
    for(int i = 1; i < hash_size; i ++)
     {
        if(elem[pos].stat==0)
         {
            //success
            elem[pos].key = e;
            elem[pos].stat = 1;
            dataNum++;
            cout<<"Insert Value Success!The value is:"<<e<<";the addr is:"<<pos<<endl;
            return true;
        }
        pos = (pos1+i)%hash_size;
    }
    cout<<"Insert Value Faliure"<<endl;
    return false;
}

bool HashTable::search(int key, int* pos)
{
    int hashvalue = hash(key);
    for(int i = 1; i< hash_size; i ++)
     {
        if(elem[hashvalue].stat==1&&elem[hashvalue].key == key)
         {
            cout<<"Search Success!Search Nums="<<i<<endl;
            *pos = hashvalue;
            return true;
        }
        hashvalue = (hashvalue+1)%hash_size;
    }
    
    cout<<"Not found"<<endl;
    return false;
}

void HashTable::display()
{
    if(dataNum == 0)
     {
        cout<<"The Table is NULL"<<endl;
        return;
    }
    cout<<"************HashTable*************"<<endl;
    cout<<"addr                         value"<<endl;
    for(int i = 0; i<hash_size;i++)
     {
        if(elem[i].stat == 0)
            continue;
        else
            cout.width(4);
            cout<<elem[i].key;
            cout<<"                         ";
            cout.width(5);
            cout<<i<<endl;
    }
    cout<<"************************************"<<endl;
}

int main()
{
    int array[]= {22, 41, 53, 46, 30,13, 01,67};
    HashTable hTable(addr_scope);
    for(int i =0;i < 8;i++)
    hTable.insert(array[i]);
    hTable.display();
    return 0;
}
查找不成功的平均查找长度ASL＝（2+1+8+7+6+5+4+3+2+1+1）/11≈3.63