C++进阶_unordered系列的关联式容器

C++进阶_unordered系列的关联式容器

1.C++进阶_unordered系列的关联式容器

• unordered_map
  （1）unordered_map是存储<key,value>键值对的关联式容器，允许通过key快速的索引到与其对应的value
  （2）在unordered_map中，键值通常可以唯一的标识元素。
  （3）在内部，unordered_map没有对<key,value>按照任何特定的顺序进行排序，为了能在常数范围内找到key所对应的value,unordered_map将相同哈希值的键值对放在相同的桶中
  （4）unordered_map容器通过key访问单个元素要比map快，但在遍历元素子集的范围内迭代效率较低
  （5）unordered_map实现了直接访问操作符（operator[]），它允许使用key作为参数直接访问value
  （6）迭代器为前向迭代器

#include<iostream>
#include<string>
#include<unordered_map>

using namespace std;

int main()
{
	unordered_map<int, string> um;
	um.insert(make_pair<int, string>(2, "B"));
	um.insert(make_pair<int, string>(2, "C"));//键值重复，不会输出
	um.insert(make_pair<int, string>(1, "A"));
	um.insert(make_pair<int, string>(3, "E"));
	um.insert(make_pair<int, string>(4, "D"));
	for (auto x : um)
	{
		cout << x.first << "," << x.second << endl;
	}
	cout << um.bucket_count() << endl;//桶的数量
	for (int i = 0; i < um.bucket_count(); i++)
	{
		cout << um.bucket_size(i) << endl;//每个桶中放多少个键值对
	}
	return 0;
}

unordered_multimap
注：可以有相同的键值

#include<iostream>
#include<string>
#include<unordered_map>

using namespace std;

int main()
{
	unordered_multimap<int, string> um;
	um.insert(make_pair<int, string>(2, "B"));
	um.insert(make_pair<int, string>(2, "C"));
	um.insert(make_pair<int, string>(1, "A"));
	um.insert(make_pair<int, string>(2, "F"));
	um.insert(make_pair<int, string>(3, "G"));
	um.insert(make_pair<int, string>(3, "E"));
	um.insert(make_pair<int, string>(4, "D"));
	for (auto x : um)
	{
		cout << x.first << "," << x.second << endl;
	}
	cout << um.bucket_count() << endl;
	for (int i = 0; i < um.bucket_count(); i++)
	{
		cout << um.bucket_size(i) << endl;
	}
	return 0;
}

unordered_set
（1）unordered_set不按特定的顺序存储唯一元素的容器，允许根据元素的值快速检索单个元素
（2）在unordered_set中，元素的值同时是其唯一标识元素的键，键是不可变的，因此，unordered_set元素不能在容器中修改，但是可以插入和删除
（3）unordered_set中的元素不按任何特定的顺序排序，而是根据他们的散列值组织成桶，允许直接由值去快速访问单个元素（平均时间复杂度恒定）
（4）unordered_set容器比set容器通过其键访问单个元素的速度快
（5）容器中的迭代器是正向迭代器

#include<iostream>
#include<string>
#include<unordered_set>

using namespace std;

int main()
{
	unordered_set<string> um;
	um.insert( "B");
	um.insert( "C");
	um.insert( "A");
	um.insert( "F");
	um.insert( "G");
	um.insert( "E");
	um.insert( "D");
	for (auto x : um)
	{
		cout << x << " ";
	}
	cout << endl;
	cout << um.bucket_count() << endl;
	for (int i = 0; i < um.bucket_count(); i++)
	{
		cout << um.bucket_size(i) << " ";
	}
	cout << endl;

	unordered_set<int> umi;
	umi.insert(3);
	umi.insert(1);
	umi.insert(3);
	umi.insert(2);
	umi.insert(5);
	umi.insert(4);
	umi.insert(5);
	for (auto x : umi)
	{
		cout << x << " ";
	}
	cout << endl;
	cout << umi.bucket_count() << endl;
	for (int i = 0; i < umi.bucket_count(); i++)
	{
		cout << umi.bucket_size(i) << " ";
	}
	cout << endl;
	return 0;
}

unordered_multiset
注：可以有相同的键值

#include<iostream>
#include<string>
#include<unordered_set>

using namespace std;

int main()
{
	unordered_multiset<int> um;
	um.insert(1);
	um.insert(3);
	um.insert(1);
	um.insert(2);
	um.insert(2);
	for (auto x : um)
	{
		cout << x << " ";
	}
	cout << endl;
	cout << um.bucket_count() << endl;
	for (int i = 0; i < um.bucket_count(); i++)
	{
		cout << um.bucket_size(i) << " ";
	}
	cout << endl;
	return 0;
}

应用
（1）在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。返回重复了 N 次的那个元素

#include<iostream>
#include<vector>
#include<unordered_set>

using namespace std;

class A
{
public:
	int solution(vector<int>& B)
	{
		int N = B.size() / 2;
		unordered_multiset<int> um;
		for (auto x : B)
		{
			um.insert(x);//将vector中的值放倒unordered_multiset中
		}
		for (auto x : B)
		{
			if (um.count(x) == N)
			{
				return x;
			}
		}
	}
};

int main()
{
	A a;
	vector<int> B{ 1,4,2,1,1,5 };
	cout << a.solution(B) << endl;
	return 0;
}

（2）给定两个数组，编写一个函数来计算它们的交集

#include<iostream>
#include<vector>
#include<unordered_set>

using namespace std;

class A
{
public:
	vector<int> solution(vector<int>& v1, vector<int>& v2)
	{
		vector<int> ret;
		unordered_set<int> us1;
		for (auto x : v1)
		{
			us1.insert(x);
		}

		unordered_set<int> us2;
		for (auto x : v2)
		{
			us2.insert(x);
		}

		for (auto x : us1)
		{
			if (us2.find(x) != us2.end())
			{
				ret.push_back(x);
			}
		}
		return ret;
	}
};

int main()
{
	A a;
	vector<int> v1{ 1,2,3,4,5,6 };
	vector<int> v2{ 2,3,4,5,6,7 };
	vector<int> v3 = a.solution(v1, v2);
	for (auto x : v3)
	{
		cout << x << " ";
	}
	cout << endl;
	return 0;
}

（3）给定一个整数数组，判断是否存在重复元素（重复为1，不重复为0）

#include<iostream>
#include<vector>
#include<unordered_set>

using namespace std;

class A
{
public:
	bool solution(vector<int>& v1)
	{
		unordered_multiset<int> um;
		for (auto x : v1)
		{
			um.insert(x);
		}
		for (int i = 0; i < um.bucket_count(); i++)
		{
			if (um.bucket_size(i) > 1)
			{
				return true;
			}
		}
		return false;
	}
};

int main()
{
	A a;
	vector<int> v1{ 1,3,4,2,3 };
	cout << a.solution(v1) << endl;
	return 0;
}