C++数据结构--哈希(散列)表

Li&ShuaiShuai

已于 2024-02-06 19:41:27 修改

阅读量802

点赞数 21

文章标签：数据结构哈希算法算法 c++

于 2024-01-18 16:30:50 首次发布

本文链接：https://blog.csdn.net/qq_52568001/article/details/135667676

版权

1.哈希概念

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

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

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

搜索元素：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表 (Hash Table)(或者称散列表)。

哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

2.哈希冲突

对于两个数据元素的关键字ki和kj(i!=j)，有i!=j，但有：Hash(ki) == Hash(kj)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

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

如何解决冲突呢？

3.哈希函数

哈希函数设计原则：

哈希函数的定义域必须包括全部的关键码，散列表大小为m时，值域为0~m-1之间。
哈希函数计算出来的地址能均匀的分布在整个空间。
哈希函数比较简单

常见的哈希函数方法

1.直接定址法

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀缺点：需要事先知道关键字的分布情况使用场景：适合查找比较小且连续的情况。

2.除留余数法

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

一般常用的就是这两种，其他的方法这里就不讨论了。

4.哈希冲突的解决

常见的有两种方法：闭散列和开散列

4.1 闭散列

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

4.1.1 线性探测

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

插入

通过哈希函数获取到待插入元素在哈希表中的位置

如果该位置中没有元素则直接插入新元素，若有元素则，依次往后查找，直到找到空位置插入。

删除

采用闭散列进行删除元素时，不能直接的物理删除元素，因为这样有可能会影响之后的其他元素的搜索。比如上图中删除4，若直接删除则在查找44这个元素时，不能正确的查找到。因此在删除元素时一时采用一种逻辑删除的方式。设置一个标记。

//哈希表给每个空间一个标记
enum State{EXITS,EMPTY,DELETE};

下面为仿函数

template<class K>
struct SetKeyOfT    
{
    const K& operator()(const K& key)
    {
        return key;
    }
};

线性探测的实现

//我们为了实现复用的操作，使用了模板的形式，KeyOfT为一个仿函数，为了区分是key与pair
template<class K,class T,class KeyOfT>

template<class T>
struct HahData
{
    T _data;
    State _state;//进行逻辑删除的标记
}

class HashTable
{
publid:
    //插入
    bool Insert(const T& d)
    {
        KeyOfT koft;
        //增容 当负载因子>=0.7时增容
        //1.开一个二倍的空间出来
        //2.将数据映射到新表
        //3.释放旧表的空间
        if(_tables.size()==0||_num*10/_tables.size()>=7)
        {
            vector<HashData<T>> newtables;
            //一开始是0的话，则给一个厨师大小10
            size_t newsize = _tables.size()==0?10:_tables.size()*2;
            newtables.resize(newsize);
            for(size_t i=0;i<_tables.size();i++)
            {
                if(_tables[i]._state==EXITS)
                {
                    //计算在新表中的位置 并解决冲突
                    size_t index = koft(_tables[i]._data)%newtables.size();
                    //冲突 则往后移位
                    while(newtables[index]._state==EXITS)
                    {
                        index++;
                        if(index==newtables.size())
                            index=0;
                    }
                    newtables[index]=_tables[i];
                }
            }
            _tables.swap(newtables);
        }
        
        size_t index = koft(d)%_tables.size();
        while(_tables[index]._state==EXITS)
        {
            //如果要插入的元素已经存在 则插入失败
            if(koft(_tables[index]._data)==koft(d))
                return false;
            index++;
            if(index==_tabels.size())
                index=0;
        }
        _tables[index]._data=d;
        _tables[index]._state=EXITS;    
        _num++;
        return true;
    }
    
    //查找
    HashData<T>* Find(const K& key)
    {
        KeyOfT koft;
        size_t index = koft(key)&_tables.size();
        while(_tables[index]._state!=EMPTY)
        {
            if(_tables[index]._state==DELETE&&koft(_tables[index]._data)==koft(key))
                return nullptr;
            else if(_tables[index]._state==EXITS&&koft(_tables[index]._data)==koft(key))
                return &_tables[index];
            index++;
            if(index==_tables.size())
                index=0;
        }
        return nullptr;
    }

    //删除
    bool Erase(const K& key)
    {
        HashData<T>* ret = Find(key);
        if(ret)
        {
            ret->_state=DELETE; 
            return true;
        }
        else
            return false;
    }
    
private:
    vector<HashData<T>> _tables;
    size_t _num;
};

下面为对线性探测进行测试的代码与结果

void testHashTable()
{
	HashTable<int, int, SetKeyOfT<int>> ht;
	ht.Insert(4);
	ht.Insert(14);
	ht.Insert(24);
	ht.Insert(5);
	ht.Insert(15);
	ht.Insert(25);
	ht.Insert(6);
	ht.Insert(16);
}

在插入第八个数据时，哈希表进行扩容，并将数据映射到新表中。

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

散列表的载荷因子定义为: α = 填入表中的元素个数 /散列表的长度
α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以，α越大，表明填入表中的元素越多，产生冲突的可能性就越大:反之，α越小，标明填入表中的元素越少，产生冲突的可能性就越小。实际上，散列表的平均查找长度是载荷因子α的函数，只是不同处理冲突的方法有不同的函数。
对于开放定址法，荷载因子是特别重要因素，应严格限制在0,7-0.8以下。超过0.8，查表时的CPU缓存不命中(cachemissing)按照指数曲线上升。因此，一些采用开放定址法的hash库，如Java的系统库限制了荷载因子为0.75，超过此值将resize散列表。

4.1.2 二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：Hi = (H0 + i^2)%m, 或者： Hi= (H0 -i^2 )% m。其中：i = 1,2,3…，是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。对于上面如果要插入44，产生冲突，使用解决后的情况为：

二次探测的代码实现与线性探测大致相同，只是在映射时有所区别

二次探测的代码实现

//数据的状态信息
enum State { EXITS, DELETE, EMPTY };

	
//哈希表的存储的信息
template<class T>
struct HashData
{
	T _data;
	State _state;
};

template<class K, class T, class KeyOfT>
class HashTable
{

public:

	//插入
	bool Insert(const T& d)
	{
		KeyOfT koft;
		//增容
		if (_tables.size() == 0 || _num * 10 / _tables.size() >= 7)
		{
			vector<HashData<T>> newtables;
			size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			newtables.resize(newsize);
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i]._state == EXITS)
				{
					//计算在新表中的位置
					size_t start = koft(_tables[i]._data) % newtables.size();
					size_t index = start;
					int i = 1;
					//冲突 寻找下一个位置
					while (newtables[index]._state == EXITS)
					{
						index = start;
						index = index + i * i;
						index = index % newtables.size();
					}
					newtables[index] = _tables[i];
				}
			}
			_tables.swap(newtables);
		}

		size_t start = koft(d) % _tables.size();
		size_t index = start;
		int i = 1;
		while (_tables[index]._state == EXITS)
		{
			if (koft(_tables[index]._data) == koft(d))
				return false;
			index = start;
			index = index + i * i;
			i++;
			index = index % _tables.size();
				
		}
		_tables[index]._data = d;
		_tables[index]._state = EXITS;
		_num++;
	}

	//查找
	HashData<T>* Find(const T& key)
	{
		KeyOfT koft;
		size_t start = koft(key) % _tables.size();
		size_t index = start;
		int i = 1;
		while (_tables[index]._state != EMPTY)
		{
			//若要查找的元素已被删除 则查找失败
			if (_tables[index]._state == DELETE && koft(_tables[index]._data) == koft(key))
			{
				return nullptr;
			}
			//若要查找的元素存在 则返回他的地址
			else if (_tables[index]._state == EXITS && koft(_tables[index]._data) == koft(key))
				return &_tables[index];
			index = start;
			index = index + i * i;
			index = index % _tables.size();
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		HashData<T>* ret = Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			return true;
		}
		else
			return false;
	}

private:
	vector<HashData<T>> _tables;
	size_t _num;
};

下面为二次探测的测试代码与结果

void testHashTable()
{
	HashTable<int, int, SetKeyOfT<int>> ht;
	ht.Insert(4);
	ht.Insert(14);
	ht.Insert(24);
	ht.Insert(5);
	ht.Insert(15);
	ht.Insert(25);
	ht.Insert(6);
	ht.Insert(16);
}

由于线性探测可能会产生一片一片的冲突，采用二次探测会稀疏这种冲突。

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

4.2 开散列

拉链法(哈希桶)

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

插入44后的哈希桶结构如下：

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

哈希桶的代码实现

template<class T>
struct HashNode
{
	HashNode(const T& data) : _data(data), _next(nullptr)
	{}

	T _data;
	HashNode* _next;
};

template<class K, class T, class KeyOfT>
struct _HashTableIterator
{
	typedef HashNode<T> Node;
	Node* _node;
};

//仿函数将对应的key转成可以取模的整形
//默认的仿函数直接返回key 因为有的类型可以直接取模
template<class K>
struct _Hash
{
	const K& operator()(const K& key)
	{
		return key;
	}
};

//模板特化
template<>
struct _Hash<string>
{
	size_t operator()(const string& key)
	{
		//BKDR hash
		size_t hash = 0;
		for (size_t i = 0; i < key.size(); i++)
		{
			hash += 131;
			hash += key[i];
		}
		return hash;
	}
};

//有的类型不支持取模，所以给了第四个参数 给转换成整型
template<class K, class T, class KeyOfT, class Hash = _Hash<K>>
class HashTable
{
	typedef HashNode<T> Node;
public:

	size_t HashFunc(const K& key)
	{
		Hash hash;
		return hash(key);
	}

	bool Insert(const T& data)
	{
		KeyOfT koft;
		//增容 f负载因子为1时，需要增容
		if (_num == _tables.size())
		{
			vector<Node*> newtables;
			size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			newtables.resize(newsize);
			//将旧表中的数据添加到新表中 一条链一条链添加
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					size_t index = HashFunc(koft(cur->_data)) % newtables.size();
					cur->_next = newtables[index];
					newtables[index] = cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
			_tables.swap(newtables);
		}

		size_t index = HashFunc(koft(data)) % _tables.size();
		//1.先检查这个数据是否在表中，若表中已存在 则返回false
		Node* cur = _tables[index];
		while (cur)
		{
			if (koft(cur->_data) == koft(data))
				return false;
			else
				cur = cur->_next;
		}

		//2.头插到挂的链表中
		Node* newnode = new Node(data);
		newnode->_next = _tables[index];
		_tables[index] = newnode;
		_num++;
		return true;
	}

	//查找
	Node* Find(const K& key)
	{
		KeyOfT koft;
		size_t index = HashFunc(key) % _tables.size();
		Node* cur = _tables[index];
		while (cur)
		{
			if (koft(cur->_data) == koft(key))
			{
				return cur;
			}
			else
				cur = cur->_next;
		}
		return nullptr;
	}

	//删除
	bool Erase(const K& key)
	{
		KeyOfT koft;
		size_t index = HashFunc(koft(key)) % _tables.size();
		Node* cur = _tables[index];
		Node* prev = nullptr;
		while (cur)
		{
			//若当前节点是要删除的节点时
			if(koft(cur->_data)==koft(key))
			{
				//若是第一个节点，删除时略有不同
				if (cur->_datacur = _tables[index])
				{
					_tables[index] = cur->_next;
				}
				else
				{
					prev->_next = cur->_next;
				}
				delete cur;
				cur = nullptr;
				_num--;
				return true;
			}
			//继续向下找
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}
		return false;
	}

private:
	vector<HashNode<T>*> _tables;
	size_t _num = 0;
};

哈希桶测试代码如下：

void testHashTable()
{
	//没有给第四个模板参数，会调用默认参数(缺省值)
	HashTable<int, int, SetKeyOfT<int>> ht;
	ht.Insert(4);
	ht.Insert(14);
	ht.Insert(24);
	ht.Insert(5);
	ht.Insert(15);
	ht.Insert(25);
	ht.Insert(6);
	ht.Insert(16);
	ht.Insert(26);
	ht.Insert(7);
	ht.Insert(27);
	ht.Erase(4);
	ht.Erase(14);	
}

结果

负载因子为1时，进行增容

开散列增容：桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容

开散列的思考

只能存储key为整形的元素，其他类型怎么解决？

其实本文已经在上面的代码中给出了，其它类型该怎么存储。由于最常用的就是整型和字符串型，所以我们在上面的代码中，只给出了整型和字符串型。

对字符串进行取模我们是让它的所有字符的ASCII值相加，并且采用了BKDR的方式进行处理。

还使用了模板特化和缺省值的方法，在实例化哈希表的时候不需要显式的传模板参数。

5.开散列与闭散列比较

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

Li&ShuaiShuai

关注

21
点赞
踩
11

收藏

觉得还不错? 一键收藏
1
评论
C++数据结构--哈希(散列)表

α = 填入表中的元素个数 /散列表的长度α是散列表装满程度的标志因子。由于表长是定值，α与“填入表中的元素个数”成正比，所以，α越大，表明填入表中的元素越多，产生冲突的可能性就越大:反之，α越小，标明填入表中的元素越少，产生冲突的可能性就越小。实际上，散列表的平均查找长度是载荷因子α的函数，只是不同处理冲突的方法有不同的函数。对于开放定址法，荷载因子是特别重要因素，应严格限制在0,7-0.8以下。超过0.8，查表时的CPU缓存不命中(cachemissing)按照指数曲线上升。
复制链接

扫一扫