1、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_maps实现了直接访问操作符(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>(5, "E"));
um.insert(make_pair<int, string>(4, "D"));
for(auto& e : um)
{
cout<<e.first<<"|"<<e.second<<endl;
}
cout<<um.bucket_count()<<endl;
for(int i = 0; i < um.bucket_count(); ++i)
{
cout<<um.bucket_size(i)<<endl;
}
return 0;
}
#include<iostream>
#include<string>
#include<unordered_map>
using namespace std;
int main()
{
unordered_multimap<int, string> umm;
umm.insert(make_pair<int, string>(3, "C"));
umm.insert(make_pair<int, string>(2, "B"));
umm.insert(make_pair<int, string>(3, "C"));
umm.insert(make_pair<int, string>(4, "D"));
umm.insert(make_pair<int, string>(3, "C"));
umm.insert(make_pair<int, string>(5, "E"));
for(auto& e : umm)
{
cout<<e.first<<"|"<<e.second<<endl;
}
for(int i = 0; i < umm.bucket_count(); ++i)
{
cout<<umm.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> us;
us.insert("A");
us.insert("B");
us.insert("C");
us.insert("D");
us.insert("E");
us.insert("F");
us.insert("G");
for(auto& e : us)
{
cout<<e<<endl;
}
for(int i = 0; i < us.bucket_count(); ++i)
{
cout<<us.bucket_size(i)<<endl;
}
cout<<endl;
unordered_set<int> usi;
usi.insert(2);
usi.insert(4);
usi.insert(2);
usi.insert(3);
usi.insert(2);
usi.insert(1);
for(auto& e : usi)
{
cout<<e<<endl;
}
for(int i = 0; i < usi.bucket_count(); ++i)
{
cout<<usi.bucket_size(i)<<endl;
}
return 0;
}
#include<iostream>
#include<string>
#include<unordered_set>
using namespace std;
int main()
{
unordered_multiset<int> ums;
ums.insert(3);
ums.insert(4);
ums.insert(5);
ums.insert(3);
ums.insert(4);
ums.insert(2);
ums.insert(1);
ums.insert(7);
for(auto& e : ums)
{
cout<<e<<endl;
}
for(int i = 0; i < ums.bucket_count(); ++i)
{
cout<<ums.bucket_size(i)<<endl;
}
return 0;
}
2、应用
在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。返回重复了 N 次的那个元素。
#include<iostream>
#include<vector>
#include<unordered_set>
using namespace std;
class Solution
{
public:
int repeatedNTimes(vector<int>& A)
{
int N = A.size()/2;
unordered_multiset<int> ums;
for(auto& e : A)
{
ums.insert(e);
}
for(auto& e : A)
{
if(ums.count(e) == N)
{
return e;
}
}
}
};
int main()
{
Solution sol;
vector<int> A{1, 2, 3, 3, 3, 4};
cout<<sol.repeatedNTimes(A)<<endl;
return 0;
}
给定两个数组，编写一个函数来计算它们的交集。
#include<iostream>
#include<vector>
#include<unordered_set>
using namespace std;
class Solution
{
public:
vector<int> intersection(vector<int>& v1, vector<int>& v2)
{
vector<int> ret;
unordered_set<int> us1;
for(auto& e : v1)
{
us1.insert(e);
}
unordered_set<int> us2;
for(auto& e : v2)
{
us2.insert(e);
}
for(auto& e : us1)
{
if(us2.find(e) != us2.end())
{
ret.push_back(e);
}
}
return ret;
}
};
int main()
{
Solution sol;
vector<int> v1{1, 2, 2, 3, 3, 4, 5, 6, 6, 7};
vector<int> v2{3, 3, 4, 7, 8, 9, 9, 0, 1, 1};
vector<int> res = sol.intersection(v1, v2);
for(auto& e : res)
{
cout<<e<<endl;
}
return 0;
}
给定一个整数数组，判断是否存在重复元素。
#include<iostream>
#include<vector>
#include<unordered_set>
using namespace std;
class Solution
{
public:
bool containsDuplicate(vector<int>& nums)
{
unordered_multiset<int> us;
for(auto& e : nums)
{
us.insert(e);
}
for(int i = 0; i < us.bucket_count(); ++i)
{
if(us.bucket_size(i) > 1)
{
return true;
}
}
return false;
}
};
int main()
{
Solution sol;
vector<int> v1{1, 2, 3, 3};
vector<int> v2{1, 2, 3, 4};
cout<<sol.containsDuplicate(v1)<<endl;
cout<<sol.containsDuplicate(v2)<<endl;
return 0;
}
给定两个句子 A 和 B 。 （句子是一串由空格分隔的单词。每个单词仅由小写字母组成。）如果一个单词在其中一个句子中只出现一次，在另一个句子中却没有出现，那么这个单词就是不常见的。
#include<iostream>
#include<string>
#include<vector>
#include<unordered_set>
using namespace std;
class Solution
{
public:
vector<string> uncommonFromSentences(string A, string B)
{
vector<string> ret;
unordered_multiset<string> umsa;
unordered_multiset<string> umsb;
vector<string> va = splitStringToWords(A);
vector<string> vb = splitStringToWords(B);
for(auto& e : va)
{
umsa.insert(e);
}
for(auto& e : vb)
{
umsb.insert(e);
}
for(auto& e : umsa)
{
if(umsa.count(e) == 1 && umsb.count(e) == 0)
{
ret.push_back(e);
}
}
for(auto& e : umsb)
{
if(umsb.count(e) == 1 && umsa.count(e) == 0)
{
ret.push_back(e);
}
}
return ret;
}
private:
vector<string> splitStringToWords(string str)
{
vector<string> ret;
string s;
for(int i = 0; i < str.size(); ++i)
{
if(str[i] == ' ')
{
ret.push_back(s);
s.clear();
}
else
{
s += str[i];
if(i == (str.size() - 1))
{
ret.push_back(s);
}
}
}
return ret;
}
};
int main()
{
Solution sol;
string A("this apple is sweet");
string B("this apple is sour");
vector<string> res = sol.uncommonFromSentences(A, B);
for(auto& e : res)
{
cout<<e<<endl;
}
return 0;
}
