目录
前言
一、什么是哈希表
二、哈希表的操作
2.1 操作时间复杂度
2.2 哈希表通用API
2.3 建立哈希表
2.3 哈希表常见结构介绍
Set（集合）
Map（映射）
unordered_map（哈希表）
三、哈希表的力扣经典题目
有效的字母异位词242
两个数组的交集 349
两数之和1
四数相加II 454
三数之和 15
四数之和 18
前言
本文将从哈希表的概念、复杂度、STL实现函数、哈希表相关经典题目展开叙述。
一、什么是哈希表
哈希表是散列表，就是通过关键码值而直接进行访问的一种数据结构
哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素
其内部由一个个key：value 样式的键值对组成。
哈希表中的key通过哈希函数得到内存地址，然后将key和value放到对应的内存地址，从而实现通过key获取Value的方式
哈希碰撞：2个不同的key通过哈希函数（hash function）得到了相同的内存地址，也就是是内存地址已经被一个占用了，解决方法是将其中之一变为链表结构，使用next指向。这样内存地址就不会重复，但是会影响查询
二、哈希表的操作
2.1 操作时间复杂度
1) 搜索：1.无哈希碰撞，直接用哈希函数通过Key定位到内存地址,复杂度O(1) 2.有哈希碰撞，因为存在内存地址需要通过链表查询,复杂度O(N)
2) 插入：通过key找到内存地址插入即可,复杂度 O(1)--自动插入
unorder_map<int,int> InquireMap;
InquireMap[val] = 1;3) 删除：通过key找到内存地址删除即可,复杂度 O(1)
2.2 哈希表通用API
- begin()：该函数返回一个指向哈希表开始位置的迭代器
- end()：返回一个指向哈希表结尾位置的下一个元素的迭代器
- empty()：判断哈希表是否为空，空则返回true，非空返回false
- size()：返回哈希表的大小
- erase()： 删除某个位置的元素，或者删除某个位置开始到某个位置结束这一范围内的元素， 或者传入key值删除键值对
- at()：根据key查找哈希表中的元素
- clear()：清空哈希表中的元素
- find()：以key作为参数寻找哈希表中的元素，如果哈希表中存在该key值则返回该位置上的迭代器，否则返回哈希表最后一个元素下一位置上的迭代器
- count()： 统计某个key值对应的元素个数 （注：因为unordered_map不允许重复元素，所以返回值为0或1）
2.3 建立哈希表
unordered_map<char,int> correspond{
{'I',1},
{'V',5},
{'X',10},
{'L',50},
{'C',100},
{'D',500},
{'M',1000},
};2.3 哈希表常见结构介绍
总体结构上分为数组、set、map
数组也是一种意义上的哈希表
set的结构中每个元素都是一个值（类似于数组）
map的结构是一个 key:value 的数据结构
Set（集合）
1） set、multiset 基于红黑树（一种平衡二叉搜索树），所以（key）值都是有序的，但是不可以修改，一旦修改就会引起整棵树的错乱，所以只能删除和增加，两者唯一的区别是前者不可重复（key）值，后者可以重复
2）unordered_set 底层实现为哈希表，区别就是没有关键码这个说法,哈希表是无序的，所以查询效率要快些O(1)就可以实现。因为无序，所以值也不可以重复
小结：当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。
这三种数据结构的具体优劣在这里引用一张表来直观体现
| 集合 | 底层实现 | 是否有序 | 数值是否可以重复 | 能否更改数值 | 查询效率 | 增删效率 |
|---|---|---|---|---|---|---|
| std::set | 红黑树 | 有序 | 否 | 否 | O(log n) | O(log n) |
| std::multiset | 红黑树 | 有序 | 是 | 否 | O(logn) | O(logn) |
| std::unordered_set | 哈希表 | 无序 | 否 | 否 | O(1) | O(1) |
Map（映射）
1）map、multimap 基于红黑树（一种平衡二叉搜索树），key是有序的，和上面提到的set、multimap一样，key值可以添加、删除，但是不可以更改（map中，对key是有限制，对value没有限制的。所以说value值可以修改）两者唯一的区别是前者不可重复key值，后者可以重复
2）unordered_map 底层实现为哈希表（无序），因为无序，所以key也不可以重复
| 映射 | 底层实现 | 是否有序 | 数值是否可以重复 | 能否更改数值 | 查询效率 | 增删效率 |
|---|---|---|---|---|---|---|
| std::map | 红黑树 | key有序 | key不可重复 | key不可修改 | O(logn) | O(logn) |
| std::multimap | 红黑树 | key有序 | key可重复 | key不可修改 | O(log n) | O(log n) |
| std::unordered_map | 哈希表 | key无序 | key不可重复 | key不可修改 | O(1) | O(1) |
unordered_map（哈希表）
这个数据结构更加常用，所以在这里特别讲一下它的性质
- unordered_map底层存储的是<key,value>键值对，可以通过key快速的索引到value unordered_map内部因为是数据是通过映射存入哈希桶内的，所以对unordered_map进行遍历得到的是一个无序的序列。
- unordered_map通过key进行访问的速度比map快，但是遍历元素的迭代效率就要低于map了。unordered_map也实现了operator[ ] 可以通过key直接访问到value
三、哈希表的力扣经典题目
有效的字母异位词242
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
class Solution {
public:
bool isAnagram(string s, string t) {
int hash[26] = {0};//26个英文字符
for(int i =0 ;i<s.size();i++){
hash[s[i]-'a']++;
}
for(int i =0 ;i<t.size();i++){
hash[t[i]-'a']--;
}
for(int i =0 ;i<26;i++){
if(hash[i] != 0){
return false;
}
}
return true;
}
};题解:
使用哈希表的一种实现方式--数组--通过索引存储对应的值。
具体体现于每一个元素与‘a’的差值作为索引，出现次数作为索引对应的值，通过判断出现次数是否相同（为0）得到题解
两个数组的交集 349
给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> result;
unordered_set<int> nums1_map(nums1.begin(),nums1.end());
for(int i=0;i<nums2.size();i++){
if(nums1_map.find(nums2[i]) != nums1_map.end()){
//说明是交集
result.insert(nums2[i]);
}
}
return vector<int>(result.begin(),result.end());
}
};题解：
由于交集是限制了返回唯一的元素，所以需要有一种数据结构既可以存储相同的元素，又可以返回唯一的值。使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。
思路是将vector容器中的所有元素，以键值对的方式存入unordered_set容器中，此时已经去重复了，对应的key只会存在一个
利用find的方法判断是否和nums2匹配，匹配就将元素存入result哈希表容器中，最终转化为vector容器返回即可
两数之和1
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
//分别将数值作为key，下标作为value
unordered_map<int,int> result;
for(int i =0;i<nums.size();i++){
auto turn = result.find(target-nums[i]);
if(turn!= result.end()){
//存在则返回
return {turn->second,i};
}else{
result.insert(pair<int,int>(nums[i],i));
}
}
return {};
}
};题解：
两数之和可以转换为有序存储的同时，计算有没有满足的存在
并且由于需要比较大小，还需要返回下标，所以要进行map的存储方式
四数相加II 454
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例 1：
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int,int> countAB;
int count = 0;
for(int i : nums1){
for(int j : nums2){
countAB[i+j]++;//储存起来数值对应的次数
}
}
for(int i : nums3){
for(int j : nums4){
//因为c++会自动给未创建的键值对自动增加
int target = 0 - (i+j);
if(countAB.find(target)!=countAB.end()){
count += countAB[target];
}
}
}
return count;
}
};题解：
首先考虑存储每种结果对应的次数，结果不可重复，所以在这里，最好使用unordered_map来实现，
原理是得出nums1和nums2的所有结果（每一种对应几种可能），然后再遍历让nums3+nums4每一种可能对应的结果去查询nums1+nums2的结果，如果满足条件（nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0），总结果加上哈希表中对应的结果的次数，最终返回的就是所有结果的次数
三数之和 15
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
int left=0,right=0;
vector<vector<int>> result;//定义返回的数组
sort(nums.begin(),nums.end());
for(int i = 0;i<nums.size();i++){
if(nums[i]>0){
break;//说明已经不可能存在了
}
if(i>0 && nums[i] == nums[i-1]){
continue;//去重，该数字如果已经用过了，就不再用了
}
left = i+1;
right = nums.size()-1;
//基于当前的nums[i]进行后面所有可能的存入result
while(left < right){
int sumNum = nums[i]+nums[left]+nums[right];
if(sumNum > 0){
right--;
}else if(sumNum < 0){
left++;
}else{
result.push_back(vector<int>{nums[i],nums[left],nums[right]});//插入一整个数组
//去重
while(right > left && nums[right] == nums[right-1]){
right--;
}
while(right > left && nums[left] == nums[left+1]){
left++;
}
//当去完重之后进行原来的操作--收缩指针--原先的都已经用过了，已经为恰好满足
right--;
left++;
}
}
}
return result;
}
};题解：
整体上的思路是用双指针替代了哈希表的算法。因为需要返回一个二维数组，并且包括每一种可能，并且还要不重复，所以在这里使用双指针去重的思路。
排序整个数组，从不重复的数字开始，作为i元素，之后在后面的区间里设置j和k两个元素在其各自去重的情况下，计算和是否满足为0，j和k两个元素作为双指针从i+1的位置和size-1的位置向中心移动，移动时检测去重，最终返回结果
四数之和 18
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
sort(nums.begin(),nums.end());
vector<vector<int>> result;
//顺序k，i，left，right
for(int k =0;k<nums.size();k++){
if(nums[k] > target && nums[k] >=0){
//剪枝处理--便于执行（只大于不等于--因为等于可能也是一种解法 target 0 0 0）
//因为只要求k，i，left，right互不相同就可以，去重也是为了防止元素间的对应，就比如当前这个元素使用过了，就不能再使用，两个是分开的意思
break;
}
if(k>0 && nums[k]==nums[k-1]){
continue;//去重
}
for(int i=k+1;i<nums.size();i++){
if(nums[i]+nums[k] > target && nums[i]+nums[k] >= 0){
//剪枝处理的原理是当前的元素大于target，并且两元素大于0，说明后面不可能成立了（都大于0）
break;
}
//去重一定是从k之后元素开始算，因为这也是i的范围
if(i>k+1 && nums[i] == nums[i-1]){
continue;
}
int left = i+1;
int right = nums.size()-1;
while(left <right){
long targetNum =(long)nums[k]+nums[i]+nums[left]+nums[right];
if(targetNum > target){
right--;
}else if(targetNum < target){
left++;
}else{
result.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});
while(left <right && nums[right]== nums[right-1]){
right--;
}
while(left <right && nums[left]==nums[left+1]){
left++;
}
//这里再一步的原因是当前的rightleft仍为之前的rightleft
right--;
left++;
}
}
}
}
return result;
}
};题解：
总体上的思路和三数之和相似，但是外面包裹了一层K的判断，就相当于k和i都已经确定，两者分别要进行剪枝和去重的操作，内部仍然是双指针的循环判断
注意：剪枝和处理的原理文章来源：https://www.toymoban.com/news/detail-841756.html
剪枝处理--便于执行（只大于不等于--因为等于可能也是一种解法 target 0 0 0）
因为只要求k，i，left，right互不相同就可以，去重也是为了防止元素间的对应，就比如当前这个元素使用过了，就不能再使用，两个是分开的意思文章来源地址https://www.toymoban.com/news/detail-841756.html
到了这里，关于哈希表C++哈希表详解（知识点+相关LeetCode题目）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
