哈希表（散列表） C++实现

哈希函数

哈希函数就是 关键字Key 到 值Value 的映射：

Value = f(Key)

Value反映的是关键字Key的存储地址。

哈希函数的构造方法

1. 直接定址法

f(Key) = a * Key + b

例如存放不同出生年份的人口数量，出生年份是关键字，那么可以用直接定址法。

直接定址法的优点是简单均匀，也不会产生冲突；缺点是该方法适合表比较小且连续的情况，所以 该方法虽然简单但是并不常用。

2. 数字分析法

f(130xxxx1234) = 1234

该方法抽取关键字的一部分作为Value存储位置，例如电话号码取后四位作为Value。

该方法适合关键字位数比较大，且知道关键字分布位分布比较均匀的情况。

3. 平方取中法

f(Key) = Key * Key 再取中间数

假设关键字是1234，那么它的平方就是 1522756，再取中就得到 Value=227。

该方法适合位数不是 很大，并且不知道关键字分布的情况。

4. 折叠法

f(9876543210) = 987 + 654 + 321 + 0 = 1962 再取后三位 = 962

折叠法是将关键字分成位数相等的几个部分，再直接相加后取后几位作为散列地址。

折叠法适合关键字位数比较多，且不知道关键字分布的情况。

5. 除留余数法

**f(Key) = key mod p **

将Key除以p得到的值作为Value存储地址，通常p是小于哈希表长的最大质数。

6. 随机数法

f(Key) = random(Key)

也就是选取关键字的随机函数作为它的散列地址。

处理散列冲突的方法

1. 开放定址法

f(Key) = (f(Key) + d_i ) MOD p

根据 d_i 的变化，开放定址法又可以分为以下三种情况：

• 线性探测法 : d_i = 1 , 2, … , p-1
• 平方探测法: d_i = 1², -1², 2² , -2²…
• 随机探测法：d_i 取一组随机数

2. 再散列法

f(key) = RH(Key)

当发生冲突时，就换一个散列函数进行计算，总有一个散列函数会把冲突解决掉。

3. 链地址法

将相同Value的不同Key值用链表的形式存放，这样的好处是绝不会发生冲突，缺点是查找时遍历单链表会带来性能的损耗。

4. 公共区溢出法

用一块新的内存来存放发生冲突的数据。查找时先在基本表中进行查找，如果没有 找到再在溢出表中进行顺序查找。如果在基本表中冲突较小的话，公共区溢出法也是一个好方法。

散列表性能分析

如果没有冲突，散列表的查找效率无疑是最高的，但是实际应用中不可能没有冲突，所以 散列表 的查找性能还取决于以下因素：

1. 散列函数是否均匀

2. 处理冲突的方法

3. 散列表的装填因子
   装填因子 = 填入表中的记录个数 / 表的长度，代表着散列表的装满程度，越大越容易发生冲突。

散列表C++代码实现

构造方法采用 除留余数法
解决冲突的方法采用 开放定址法的线性探测法

#include <iostream>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <queue>
#include <set>
#include <vector>
#include <fstream>
#include <sstream>
#include <string.h>
#include <memory>
#include <limits>
#include <list>
#include <regex>
#include <functional>
#include <math.h>
#include <unordered_set>
#include <iomanip>
using namespace std;

/*
哈希表：
理解上可以理解成C++中的unordered_set
构造方法采用 除留余数法
解决冲突的方法采用 开放定址法的线性探测法
*/
const int NULLKEY = INT32_MIN;
class  HashTable
{
   int *_elem; 
   int _size;

public:
   HashTable(int size)
   :_size(size)
   {
      cout << "HashTable()" << endl;
      _elem = (int*)malloc(_size*sizeof(int));
      for (int i = 0; i < _size; ++i)
            _elem[i] = NULLKEY;
   }

   int Hash(int key) //哈希函数的构造方法，采用除留余数法
   {
      return key % _size;
   }

   void insert(int key)
   {
      int addr = Hash(key);
      while (_elem[addr] != NULLKEY)//如果发生冲突，那么采用开放地址法中的线性探测法
         addr = (addr + 1) % _size;
      _elem[addr] = key;
   }

   bool search(int key)
   {
      int addr = Hash(key);
      while(_elem[addr] != key)
      {
         if (_elem[addr] == NULLKEY)
            return false; //关键字不存在
         addr = (addr + 1) % _size;
         if (addr = Hash(key))
            return false; //重新回到原点
      }
      return true;
   }

   void print() const
   {
      cout << "下标：";
      for (int i = 0; i < _size; ++i)
         cout << setw(4) << i;
      cout << endl;
      
      cout << "关键字:";
      for (int i = 0; i < _size; ++i)
         cout << setw(4) << _elem[i];
      cout << endl;
   }

};


int main()
{
   vector<int> nums{12, 67, 56, 16, 25, 37, 22, 29, 15, 47, 48, 34};
   HashTable hashtable(nums.size());
   for (auto& e: nums)
      hashtable.insert(e);
   hashtable.print();      
   return 0;
}