目录

unordered系列容器的底层结构

哈希概念

哈希冲突

哈希函数

常见哈希函数

哈希冲突解决

闭散列

线性探测

哈希表什么情况下进行扩容？如何扩容？

二次探测

开散列

开散列概念

开散列增容

存储string类型的解决

闭散列的实现

开散列的实现

开散列与闭散列比较

---

unordered系列容器的底层结构

unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。

哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素 时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即 O(logN)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立 一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

• 插入元素

根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

• 搜索元素

对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置 取元素比较，若关键码相等，则搜索成功

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称 为哈希表(Hash Table)(或者称散列表)

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快

哈希冲突

按照上述哈希方式，向集合中插入相同元素，会出现什么问题？

不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

哈希函数

发生哈希冲突该如何处理呢？

引起哈希冲突的一个原因可能是：哈希函数设计不够合理

哈希函数设计原则：

• 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
• 哈希函数计算出来的地址能均匀分布在整个空间中
• 哈希函数应该比较简单

常见哈希函数

• 直接定址法(常用)

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B

优点：简单、均匀

缺点：需要事先知道关键字的分布情况

使用场景：适合查找比较小且连续的情况

面试题：字符串中第一个只出现一次字符

• 除留余数法(常用)

设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数， 按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

• 平方取中法(了解)

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址

再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址

平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

• 折叠法(了解)

折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这 几部分叠加求和，并按散列表表长，取后几位作为散列地址。

折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

• 随机数法(了解)

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中 random为随机数函数。

通常应用于关键字长度不等时采用此法

• 数学分析法(了解)

设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定 相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只 有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散 列地址。

例如：假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同 的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还 可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移 位、前两数与后两数叠加(如1234改成12+34=46)等方法。

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的 若干位分布较均匀的情况

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

哈希冲突解决

解决哈希冲突两种常见的方法是：闭散列和开散列

闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有 空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。

那如何寻找下一个空位置呢？

线性探测

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

• 插入

1. 通过哈希函数获取待插入元素在哈希表中的位置
2. 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突， 使用线性探测找到下一个空位置，插入新元素

hash(key)%N+i

•  删除

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素 会影响其他元素的搜索。

比如删除元素4，如果直接删除掉，44查找起来可能会受影响。

因此线性探测采用标记的伪删除法来删除一个元素。

// 哈希表每个空间给个标记
// EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE};

哈希表什么情况下进行扩容？如何扩容？

散列表的载荷因子定义为：α = 填入表中的元素个数 / 散列表的长度

α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以α越大，表明填入表中的元素越多，产生冲突的可能性越大；反之，α越小，表明填入表中的元素越少，产生冲突的可能性就越小。实际上，散列表的平均查找长度是载荷因此α的函数，只是不同处理冲突的方法有不同的函数。

对于开放定址法，载荷因子是特别重要因素，因严格限制在0.7-0.8以下。超过0.8查表时的CPU缓存不命中，按照指数曲线上升。因此，一些采用开放定址法的hash库，如Java的系统库限制了载荷因子为0.75，超过此值将resize散列表

线性探测优点：实现非常简单

线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同 关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。

二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位 置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题

找下一个空位置的方法：

hash(key)%N+i^2

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任 何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在 搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。

因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

开散列

开散列概念

开散列法又叫链地址法(拉链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中，因此也叫哈希桶。

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

开散列增容

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？

开散列最好的情况是：

每个哈希桶中刚好挂一个节点， 再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。

存储string类型的解决

比较常用的是除留余数法，模一个素数

每次快速取一个类似两倍关系的素数可以采用如下代码：

size_t GetNextPrime(size_t prime)
{
    const int PRIMECOUNT = 28;
    static const size_t primeList[PRIMECOUNT] =
    {
         53ul, 97ul, 193ul, 389ul, 769ul,
         1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
         49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
         1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
         50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
         1610612741ul, 3221225473ul, 4294967291ul
    };
    size_t i = 0;
    for (; i < PRIMECOUNT; ++i)
    {
         if (primeList[i] > prime)
             return primeList[i];
    }
    return primeList[i];
}

以下是大佬们创造的字符串哈希算法

字符串哈希算法

下面实现开散列和闭散列采用的就是其中的BKDR算法

闭散列的实现

使用数据结构中的vector实现线性探测/二次探测的哈希表：

#pragma once
#include <vector>

//vector每个位置的状态
enum State
{
    EMPTY,
    EXITS,
    DELETE
};

//vector中的数据类型
template<class K, class V>
struct HashDate
{
    pair<K, V> _kv;//存储数据
    State _state = EMPTY;//状态默认为空
};

//使用仿函数转key
//整形直接转
template<class K>
struct DefaultHash
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }  
};
//模板特化处理string类型
template<>
struct DefaultHash<string>
{
    size_t operator()(const string& key)
    {
        size_t hashi = 0;
        //BKDR算法
        for(auto& e : key)
            hashi = hashi * 131 + e;
        return hashi;
    }
};

//默认传的整形的hashFunc
template<class K, class V, class HashFunc = DefaultHash<K>>
class HashTable
{
public:
    bool insert(const pair<K, V>& kv)
    {
        //存在的元素不能插入
        if(find(kv.first))
            return false;

        //负载因子达到0.7需要扩容
        if(_table.size() == 0 || _n*10/_table.size() >= 7)
        {
            //防止空间为0
            size_t newsize = _table.size() == 0 ? 10 : _table.size()*2;
            //创建新表存入数据
            HashTable<K, V> newHT;
            newHT._table.resize(newsize);
            for(auto& e : _table)
            {
                if(e._state == EXITS)
                    newHT.insert(e._kv);
            }
            //将两表数据交换
            newHT._table.swap(_table);
        }
        
        //扩完容或者不需要扩容后插入
        HashFunc hf;
        size_t starti = hf(kv.first);//获取位置
        starti %= _table.size();//映射到哈希表上
        //线性探测，二次探测
        size_t hashi = starti;
        size_t i = 1;
        while(_table[hashi]._state == EXITS)
        {
            hashi = hashi + i;
            //hashi = hashi + i * i//这行代码即是二次探测
            ++i;
            hashi %= _table.size();//防止越界
        }
        
        //找到位置后存储数据
        _table[hashi]._kv = kv;
        _table[hashi]._state = EXITS;
        ++_n;
        return true;
    }
    
    //查找
    HashDate* find(const K& key)
    {
        //空表无法查找
        if(_table.empty())
            return nullptr;

        //获取位置key
        HashFunc hf;
        size_t starti = hf(key);
        starti %= _table.size();
        
        //查找key
        size_t hashi = starti;
        size_t i = 1;
        while(_table[hashi]._state != EMPTY)
        {
            if(_table[hashi]._state == EXITS && _table[hashi]._kv.first == key)
            return &_table[hashi];
            hashi = hashi + i;
            ++i;
            hashi %= _table.size();
        }
        
        //找不到返回空指针
        return nullptr;
    }

    //删除
    bool erase(const K& key)
    {
        HashDate* ret = find(key);
        if(ret)
        {
            ret->_state = DELETE;
            --_n;
            return true;
        }
        else
        {
            return false;
        }
    }

private:
    vector<HashDate> _table;
    size_t _n = 0;
}

开散列的实现

在开散列中，数据不存在表中，表里面存储一个链表指针，冲突的数据以链表的形式挂起来，其结构是数组+链表，因此采用vector+单链表数据结构实现：

#pragma once
#include <vector>

namespace Bucket
{
	//默认接收整形
	template<class K>
	struct DefaultHash
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};
	//针对接收string特化
	template<>
	struct DefaultHash<string>
	{
		size_t operator()(const string& key)
		{
			size_t hashi = 0;
			for (auto& ch : key)
				hashi = hashi * 131 + ch;
			return hashi;
		}
	};

	//节点的实现
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode* _next;

		HashNode(const pair<K, V>& kv)
			:_kv(kv)
			,_next(nullptr)
		{}
	};

	template<class K, class V, class HashFunc = DefaultHash<K>>
	struct HashTable
	{
		typedef HashNode Node;
	public:

		//析构函数需要自己实现，vector存的是内置类型，不会释放节点，只会释放表
		~HashTable()
		{
			for (int i = 0; i < _table.size(); ++i)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->_next;
					if (cur)
						delete cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
		}

		bool insert(const pair<K, V>& kv)
		{
			//不存入key值相同数据
			if (find(kv.first))
				return false;

			//负载因子大小和表的大小一样大的时候扩容
			if (_table.size() == _n)
			{
				size_t newsize = _table.size() == 0 : 10 : _table.size() * 2;
				vector<Node*> newtable;
				newtable.resize(newsize, nullptr);
				//遍历旧表，将旧表中的节点插入到新表中
				for (int i = 0; i < _table.size(); ++i)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;//存储next方便更新cur
						//寻找该节点在新表中的位置
						size_t hashi = HashFunc()(kv.first) % newsize;
						//单链表的头插
						cur->_next = newtable[hashi];//将待插入节点的next指向待插入位置的第一个节点
						newtable[hashi] = cur;//将待插入节点插入到待插入位置
						cur = next;//更新cur
					}
					_table[i] = nullptr;//将旧表位置置空
				}
				newtable.swap(_table);//将处理好的数据交换给旧表
			}

			//经过上面处理后将数据存入
			size_t hashi = HashFunc()(kv.first) % _table.size();
			//将节点头插到链表中
			Node* newnode = new Node(kv);
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			
			++_n;

			return true;
		}

		Node* find(const K& key)
		{
			//表空无法查找
			if (_table.size() == 0)
				return nullptr;

			size_t hashi = HashFunc()(key) % _table.size();

			//从计算到位置处开始查询该处链表中是否存在该key
			Node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
					return cur;
				cur = cur->_next;
			}

			return nullptr;
		}

		bool erase(const K& key)
		{
			//表为空无法删除
			if (_table.size() == 0)
				return false;

			size_t hashi = HashFunc()(key) % _table.size();

			//找到对应位置后进行单链表的删除
			Node* cur = _table[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				//单链表的头删和普通删除
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
						_table[hashi] = cur->_next;
					else
						prev->_next = cur->_next;
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}

			return false;
		}

	private:
		vector<Node*> _table;//每个位置存储链表
		size_t _n = 0;//负载因子
	};
}

开散列与闭散列比较

应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。

事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。