C++&&数据结构——哈希表

最新推荐文章于 2024-02-26 08:37:50 发布

与你日常

最新推荐文章于 2024-02-26 08:37:50 发布

阅读量1.1k

点赞数 24

文章标签：散列表数据结构 c++

本文链接：https://blog.csdn.net/aaqq800520/article/details/135773395

版权

一，unordered系列容器

1.1 关于unordered系列

在C++98中，STL提供了以红黑树为底层的一系列关联式容器，查询时效率可达到logN，但是当树中节点非常多时，查询效率也不理想，所以在C++11中，STL提供了unordered系列的几个容器，使用哈希表作为底层，大大增加了查询效率

1.2 unordered_set

关于unordered_set的使用和之前介绍的set大体相同，如下代码：

void test_unordered_set()
{
	unordered_set<int> s;
	s.insert(2);
	s.insert(3);
	s.insert(1);
	s.insert(2);
	s.insert(5);

	unordered_set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

1.4 unordered_map

void test_unordered_map()
{
	string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨" };
	map<string, int> countMap;
	for (auto& e : arr)
	{
		countMap[e]++;
	}

	for (auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}

1.5 性能对比

void test_op() //测试性能
{
	//产生n个随机数
	int n = 100000;
	vector<int> v;
	v.reserve(n);
	srand(time(0));
	for (int i = 0; i < n; ++i)
	{
		//把n个随机数放到vector里去
		//v.push_back(i); //有序插入
		// //v.push_back(rand());  // 重复多
		v.push_back(rand() + i);  // 重复少
	}
	size_t begin1 = clock();
	set<int> s;
	for (auto e : v)
	{
		s.insert(e);//先往set插入
	}
	size_t end1 = clock(); 

	size_t begin2 = clock();
	unordered_set<int> us;
	for (auto e : v)
	{
		us.insert(e);//再往unordered_set插入
	}
	size_t end2 = clock();

	cout << "size:" << s.size() << endl;

	cout << "set insert:" << end1 - begin1 << endl; //算出set插入时间
	cout << "unordered_set insert:" << end2 - begin2 << endl; //算出unordered_set插入时间
	cout << endl;

	size_t begin3 = clock();
	for (auto e : v)
	{
		s.find(e);
	}
	size_t end3 = clock();

	size_t begin4 = clock();
	for (auto e : v)
	{
		us.find(e);
	}
	size_t end4 = clock();
	//对比查找效率
	cout << "set find:" << end3 - begin3 << endl;
	cout << "unordered_set find:" << end4 - begin4 << endl;
	cout << endl;

	size_t begin5 = clock();
	for (auto e : v)
	{
		s.erase(e);
	}
	size_t end5 = clock();

	size_t begin6 = clock();
	for (auto e : v)
	{
		us.erase(e);
	}
	size_t end6 = clock();
	//对比删除效率
	cout << "set erase:" << end5 - begin5 << endl;
	cout << "unordered_set erase:" << end6 - begin6 << endl;

	unordered_map<string, int> countMap;
	countMap.insert(make_pair("苹果", 1));

	//可以支持
	unordered_map<string, int> countmap;
	countmap.insert(make_pair("苹果", 1));
	//综合各种场景而言，unordered系列综合性能是更好的，尤其是find
}

二，哈希

2.1 哈希概念

哈希本质是一种设计思路。

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

所以，为了使查找效率更高，推出了一种理想的搜索方法，即不经过任何比较，一次直接从表中查到相关的数据。如果构造一种存储结构，通过某种函数(HashFunc)使元素的存储位置与它的关键码之间建立一一映射的关系，那么查找时能很快找到该数据。

向该结构中：

①插入元素：根据插入元素的key值，以此函数计算出该元素的存储位置进行存放

②查找元素：对要查找元素的key值进行相同的计算，得出存储位置，再对比关键码查看结构当中是否有该元素

该方法被称为哈希（散列）方法，哈希方法中使用的位置计算函数称为哈希（散列）函数，构造出来的结构称为哈希表

例如：数据集合{ 1,6,7,4,5,9 }，哈希函数设置为hash(key) = key % capacity

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

2.2 常用哈希函数

1，直接定值法

取关键字的某个线性函数为散列地址:Hash(key) = A*key + B。

这种方法的优点是简单，缺点是需要提前直到关键字的分布情况，适合查找比较小且连续的数据

2，除留余数法

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

2.3 哈希冲突及解决

就上面的图而言，如果插入44时，会算出和4同样的位置。

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

2.3.1 闭散列

闭散列也叫开放定址法，当发生哈希冲突时，如果哈希表未被填满，说明哈必然还有其他空位置，那么可以把key存放到冲突位置的“下一个”空位置中去，这里寻找下一个位置的方法称为“线性探测”

就上面的图，我们要插入44，会发生哈希冲突，所以我们从发生冲突的位置开始依次向后探测，直到寻找到下一个空位置为止，该方法应用在插入函数中，如下图：

对于删除，采用闭散列处理哈希冲突时，不能直接删除表中的数据否则会影响其他数据的搜索，所以采用标记的伪删除法来删除，给要删除的位置打上delete的标记，具体实现请看后面的模拟实现部分

2.3.2 开散列

开散列又叫链地址法，首先对关键码集合用哈希函数计算地址，具有相同地址的关键码用一个单链表集合起来，称每个单链表为一个桶，每个链表的头结点存在哈希表中，如下图：

2.4 哈希表扩容

2.4.1 闭散列扩容

哈希表的负载因子定义为：i = 表中现有数据个数/表的总长度

由于表长是定值，i与表中现有数据个数成正比，所以，负载因子越大，表面填入表中的数据越多，产生冲突的可能性越大，负载因子越小，产生冲突的可能性越小。

对于开放定址法，负载因子必须严格限制在0.7 -- 0.8以下，超过0.8，查表时的CPU的计算效率成指数上升。因此，一些采用开放定址法的hash库，如Java的库限制了负载因子为0.75，超过将resize哈希表。扩容具体实现请看下面哈希表模拟实现部分

2.4.2 开散列扩容

桶的个数是一定的，随着数据的不断插入，每个桶中元素不断增多，极端情况下可能会导致一个桶中的链表节点非常多，影响哈希表的查找效率，所以需要对哈希表进行增容。

最好的情况是，每个桶中刚好有一个节点，再插入数据时，都会发生哈希冲突，所以在数据个数等于桶的个数时，也就是负载因子等于1的适合进行扩容

注：如果实在没办法扩容，但是又有很多值经过哈希函数运算后插入同一个地址，那么可以将桶挂单链表改为挂红黑树。