哈希表的实现(哈希捅)

今天是哈希表的实现,哈希表也是一种数据结构,我个人认为还是比较简单的,先给大家看看我 的实现代码吧,如下:

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 
//哈希捅实现哈希表
using namespace std;
namespace cc
{
	//哈希捅的每个节点
	template
	struct hashnode
	{
		pair _val;
		hashnode* _next = nullptr;
		hashnode(const pair& x)
			:_val(x)
		{}
	};
	//哈希表
	template
	class hash
	{
	public:
		typedef hashnode node;
		hash()
		{}
		hash(const hash& h)
		{
			_table.resize(h._table.size(), nullptr);
			for (size_t i = 0; i < _table.size(); i++)
			{
				if (h._table[i] != nullptr)
				{
					node* cur = h._table[i];
					while (cur)
					{
						node* copy = new node(cur->_val);
						copy->_next = _table[i];
						_table[i] = copy;
						cur = cur->_next;
					}
				}
			}
			_size = h._size;
		}
		bool insert(const pair& x)
		{
			//如果需要扩容或是此时是一个空表
			//注意:这里其实有个负荷因子,因为STL中的用哈希桶实现的哈希表中,负荷因子的大小是1,所以就是相等,如果用线性探测或是二次探测
			//的方法,就不能控制在1,最好控制在0.7-0.8左右就开始扩容,扩容其实根据专业人士的研究,扩容的大小最好是质数的,出现哈希碰撞的几率
			//就比较少
			if (_size == _table.size())
			{
				vector tem;
				tem.resize(_table.size() == 0 ? 10 : _table.size() * 2, nullptr);
				//旧表节点移动到新表
				for (size_t i = 0; i < _table.size(); i++)
				{
					node* cur = _table[i];
					while (cur)
					{
						cur->_next = tem[i];
						tem[i] = cur;
						cur = cur->_next;
					}
				}
				//移动完成,交换两个表
				tem.swap(_table);
			}
			node* newnode = new node(x);
			int ret = newnode->_val.first % _table.size();
			//头插
			newnode->_next = _table[ret];
			_table[ret] = newnode;
			_size++;
			return true;
		}
		node* find(const K& key)
		{
			int ret = key % _table.size();
			node* prev = nullptr;
			node* cur = _table[ret];
			while (cur)
			{
				if (cur->_val.first == key)
					return cur;
				prev = cur;
				cur = cur->_next;
			}
			return nullptr;
		}
		bool erase(const K& key)
		{
			if (_size == 0)
			{
				cout << "无法删除空表的内容" << endl;
				return false;
			}
			int ret = key % _table.size();
			node* prev = nullptr;
			node* cur = _table[ret];
			while (cur)
			{
				if (cur->_val.first == key)
				{
					if (prev)
						prev->_next = cur->_next;
					else
						_table[ret] = cur->_next;
					delete cur;
					_size--;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
	private:
		size_t _size = 0;
		vector _table;
	};
}

上面就是我用哈希捅实现的哈希表,思维逻辑还是比较简单的,但是还是要注意的点。

先来说说哈希表的作用吧。我个人感觉哈希表就是寻找方便,时间复杂度是O(1),个人认为这应该是查找的天花板了吧,就连各种效率都很优的AVL树和红黑树都是log(n),所以个人认为这个数据结构应该是查找的天花板了,但是他的缺点也很明显。我们先来看看下面的图,来看看他的原理:

哈希表的实现(哈希捅)_第1张图片

如上,它的原理其实就是这样的,而哈希捅的实现其实使用链表来实现的,也就是每个桶都挂了一个单向链表,其实不仅可以挂单向链表,双向链表其实也可以挂,但是不用双向链表的原因是,双向链表比单链表的消耗大,所以才用的单链表,而在同一个桶的位置,挂数的时候,我们普遍用头插,这个就不说了,很容易理解,头插的时间复杂度是O(1)。

其实很多人在看到这种情况的时候,可能会懵,这中结构怎么查找的时间复杂度是O(1)呢?如果我查找的桶刚好是一个挂的非常多的,这不是就相当于O(N)了嘛,其实这个我刚开始也有这种疑惑,但是到现在我就比较释然了,我们打个比喻,最坏的情况是所有插入的数在一个桶的位置,这个是最坏的情况,但是不知道大家测试过吗?这种情况除非是人为的,也就是自己故意的,不然基本是不会出现的,因为我测试过,插入随机的十万个左右的树,它的桶数是大概好像是十二万多,而每个桶所挂起的数,最多的才是3个,普遍都是一个桶挂一个数,所以你担心的情况所出现的概率是非常低的。几乎没有,除非你是自己故意的。所以他的每个桶所挂起的数,基本是常数级别的,所以就是O(1),如果你实现是担心,其实他的每个桶的位置不一定要挂链表,也可以挂红黑树啊,这样效率不就是越来越高了嘛,所以我们不要看到一点点的缺点就不放过,而且他的这个缺点出现的概率实在是太低太低了。

我们可以看到的是,它的查找效率几乎是无敌的,因为不管查找什么,他都是映射的关系,直接映射到它的桶的位置,但是其实他的缺点也非常的大,它的缺点就是扩容的消耗太大了,因为他扩容还要把所有的数据再给新扩的这个表拷贝一份,所以这个是他的缺点。

还有就是线性探测与二次探测的方法来实现哈希表,这个后面会陆续的发。

本篇内容如果对你有用的话,希望带你一下赞吧!!!

你可能感兴趣的:(C++篇,数据结构,散列表,哈希算法,数据结构)