专题四：哈希表

一、基础知识

哈希表是根据关键码的值而直接进行访问的数据结构。

那么哈希表能解决什么问题呢，「一般哈希表都是用来快速判断一个元素是否出现集合里。」

例如要查询一个名字是否在这所学校里。

要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1) 就可以做到。

我们只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了。

将学生姓名映射到哈希表上就涉及到了「hash function ，也就是哈希函数」。

哈希函数

哈希碰撞

一般哈希碰撞有两种解决方法， 拉链法和线性探测法。

• 拉链法
  
  其实拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。

• 线性探测法

  使用线性探测法，一定要保证tableSize大于dataSize。我们需要依靠哈希表中的空位来解决碰撞问题。
  

常见的三种哈希结构

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构。

• 数组
• set （集合）
• map(映射)
  
  std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。
  
  std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。
  当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。
  那么再来看一下map ，在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。
  虽然set、multiset 的底层实现是红黑树，不是哈希表，但是set、multiset 依然使用哈希函数来做映射，只不过底层的符号表使用了红黑树来存储数据，所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法。map也是一样的道理。
  这里在说一下，一些C++的经典书籍上 例如STL源码剖析，说到了hash_set hash_map，这个与unordered_set，unordered_map又有什么关系呢？

实际上功能都是一样一样的， 但是unordered_set在C++11的时候被引入标准库了，而hash_set并没有，所以建议还是使用unordered_set比较好，这就好比一个是官方认证的，hash_set，hash_map 是C++11标准之前民间高手自发造的轮子。

总结

总结一下，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

二、数组

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:

输入: s = “rat”, t = “car”
输出: false
说明:
你可以假设字符串只包含小写字母。

进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

链接：https://leetcode-cn.com/problems/valid-anagram

思路：

「数组其实就是一个简单哈希表」，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。

需要定义一个多大的数组呢，定一个数组叫做record，大小为26 就可以了，初始化为0，因为字符a到字符z的ASCII也是26个连续的数值。

定义一个数组叫做record用来上记录字符串s里字符出现的次数。

需要把字符映射到数组也就是哈希表的索引下表上，「因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下表0，相应的字符z映射为下表25。」

再遍历字符串s的时候，「只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。」 这样就将字符串s中字符出现的次数，统计出来了。

那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

那么最后检查一下，「record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。」

最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

时间复杂度为O(n)，空间上因为定义是的一个常量大小的辅助数组，所以空间复杂度为O(1)。

代码：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int a[26]={0};
        for(int i=0;i<s.size();i++){
            a[s[i]-'a']++;
        }
        for(int i=0;i<t.size();i++){
            a[t[i]-'a']--;
        }
        for(int i=0;i<26;i++){
            if(a[i]!=0){
                return false;
            }
        }
        return true;
    }
};

例题二：

383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

示例 1：

输入：ransomNote = “a”, magazine = “b”
输出：false
示例 2：

输入：ransomNote = “aa”, magazine = “ab”
输出：false
示例 3：

输入：ransomNote = “aa”, magazine = “aab”
输出：true

提示：

你可以假设两个字符串均只含有小写字母。

链接：https://leetcode-cn.com/problems/ransom-note

思路

这道题目和242.有效的字母异位词（我们之前讲过）很像，242.有效的字母异位词相当于求 字符串a 和 字符串b 是否可以相互组成 ，而这道题目是求 字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a。

本题判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成，但是这里需要注意两点。

• 第一点“为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思” 这里说明杂志里面的字母不可重复使用。
• 第二点 “你可以假设两个字符串均只含有小写字母。” 说明只有小写字母，这一点很重要

哈希解法

因为题目所只有小写字母，那可以采用空间换取时间的哈希策略， 用一个长度为26的数组还记录magazine里字母出现的次数。

然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。

依然是数组在哈希法中的应用。

一些同学可能想，用数组干啥，都用map完事了，「其实在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数。所以数组更加简单直接有效！」

代码：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26]={0};//保存字母
        for(int i=0;i<ransomNote.size();i++){
            record[ransomNote[i]-'a']++;
        }
        for(int i=0;i<magazine.size();i++){
            record[magazine[i]-'a']--;
        }
        for(int i=0;i<26;i++){
            if(record[i]>0)
                return false;
        }
        return true;
    }
};

三、set

如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费！

第349题. 两个数组的交集

题意：给定两个数组，编写一个函数来计算它们的交集。

「说明：」
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

思路

这道题目，主要要学会使用一种哈希数据结构：unordered_set，这个数据结构可以解决很多类似的问题。

注意题目特意说明：「输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序」

这道题用暴力的解法时间复杂度是O(n^2)，那来看看使用哈希法进一步优化。

可以发现，貌似用数组做哈希表可以解决这道题目，把nums1的元素，映射到哈希数组的下表上，然后在遍历nums2的时候，判断是否出现过就可以了。

但是要注意，「使用数据来做哈希的题目，都限制了数值的大小，例如哈希表：可以拿数组当哈希表来用，但哈希值不要太大题目中只有小写字母，或者数值大小在[0- 10000] 之内等等。」

「而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。」

此时就要使用另一种结构体了，set ，关于set，C++ 给提供了如下三种可用的数据结构：

• std::set
• std::multiset
• std::unordered_set

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

代码：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
         unordered_set<int> record(nums1.begin(), nums1.end());//注意这种可以直接将vector<int>转化为unordered_set<int>的方法
        unordered_set<int> res;//注意这个也要是set类型，结果不能有重复
        
        for(int i=0;i<nums2.size();i++){
            if(record.find(nums2[i])!=record.end()){
                res.insert(nums2[i]);
            }
        }
        return vector<int>(res.begin(),res.end());//返回结果在进行一下类型转化
    }
};

例题二：

第202题. 快乐数
编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

思路

这道题目看上去貌似一道数学问题，其实并不是！

题目中说了会 「无限循环」，那么也就是说「求和的过程中，sum会重复出现，这对解题很重要！」

正如：关于哈希表，你该了解这些！中所说，「当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。」

所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

判断sum是否重复出现就可以使用unordered_set。

「还有一个难点就是求和的过程，如果对取数值各个位上的单数操作不熟悉的话，做这道题也会比较艰难。」

注意这种思路：本来一看以为是数学问题，可以转化为用这种思路来判断，主要是使用unordered_set判断sum是否重复出现

代码：

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> record;
        while(n!=1){
            int tmp=n;
            int sum=0;
            while(tmp!=0){
                sum=sum+(tmp%10)*(tmp%10);
                tmp=tmp/10;
            }
            n=sum;
            //说明sum重复出现了
            if(record.find(sum)!=record.end()){
                return false;
            }
            record.insert(sum);//注意对于unordered_set插入值的写法
        }
        return true;
    }
};

四、map

第1题. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

「示例:」

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思路

很明显暴力的解法是两层for循环查找，时间复杂度是O(n^2)。

使用哈希法最为合适，之前已经介绍过，数组和set在哈希法中的应用，那么来看一下使用数组和set来做哈希法的局限。

• 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
• set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下表位置，因为要返回x 和
  y的下表。所以set 也不能用。

此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下表。

「这道题目中并不需要key有序，选择std::unordered_map 效率更高！」

代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> record;
        for(int i=0;i<nums.size();i++){
            record[nums[i]]=i;
        }
        for(int i=0;i<nums.size();i++){
            int other=target-nums[i];
            auto iter=record.find(other);
            
     //注意这里要判断俩个下标不能相等就可以
            if(iter!=record.end()&&i!=record[other]){
                return {i,record[other]};
            }
            //  record[nums[i]]=i;//注意这里，并不需要额外写一个for循环
        }
        return {};//如果没有，注意返回的形式
    }
};

不需要再写一个for循环的代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> record;
        // for(int i=0;i<nums.size();i++){
        //     record[nums[i]]=i;
        // }
        for(int i=0;i<nums.size();i++){
            int other=target-nums[i];
            auto iter=record.find(other);
            
            if(iter!=record.end()){
                return {i,record[other]};
            }
            record[nums[i]]=i;//注意这里，并不需要额外写一个for循环，因为是求和，之后还会再求一遍
        }
        return {};//如果没有，注意返回的形式
    }
};

例题二：

第454题.四数相加II

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

「例如:」

输入: A = [ 1, 2] B = [-2,-1] C = [-1, 2] D = [ 0, 2]

输出: 2

「解释:」

两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

思路

本题咋眼一看好像和第18题. 四数之和，第15题.三数之和差不多，其实差很多。

「本题是使用哈希法的经典题目，而第18题. 四数之和，第15题.三数之和 并不合适使用哈希法」，因为三数之和和四数之和这两道题目使用哈希法在不超时的情况下做到对结果去重是很困难的，很有多细节需要处理。

「而这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于题目18. 四数之和，题目15.三数之和，还是简单了不少！」

如果本题想难度升级：就是给出一个数组（而不是四个数组），在这里找出四个元素相加等于0，答案中不可以包含重复的四元组，大家可以思考一下，后续的文章我也会讲到的。

本题解题步骤：

• 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
• 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
• 定义int变量count，用来统计a+b+c+d = 0出现的次数
• 在遍历大C和大D数组，找到如果 0-(c+d)在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
• 最后返回统计值 count 就可以了

代码：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> record; //key:a+b的数值，value:a+b数值出现的次数
        int count=0;//保存结果
        // 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中 
        for(int i=0;i<nums1.size();i++){
            for(int j=0;j<nums2.size();j++){
                record[nums1[i]+nums2[j]]++;//直接++，即可，不用管初值
            }
        }
        // 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来。
         for(int i=0;i<nums3.size();i++){
            for(int j=0;j<nums4.size();j++){
                int sum=nums3[i]+nums4[j];
                auto iter=record.find(-sum);
                if(iter!=record.end()){
                    count+=iter->second;
                    // count += record[-sum];
                }
            }
        }
        return count;
    }
};

例题：三数之和

第15题. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：[ [-1, 0, 1], [-1, -1, 2] ]

思路：

1、哈希解法

两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。

把符合条件的三元组放进vector中，然后在去去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。

去重的过程不好处理，有很多小细节，如果在面试中很难想到位。

时间复杂度可以做到O(n^2)，但还是比较费时的，因为不好做剪枝操作。

大家可以尝试使用哈希法写一写，就知道其困难的程度了。

哈希法C++代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0 
        // a = nums[i], b = nums[j], c = -(a + b)
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                continue;
            }
            if (i > 0 && nums[i] == nums[i - 1]) { //三元组元素a去重
                continue;
            }
            unordered_set<int> set;
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2
                        && nums[j] == nums[j-1]
                        && nums[j-1] == nums[j-2]) { // 三元组元素b去重
                    continue;
                }
                int c = 0 - (nums[i] + nums[j]);
                if (set.find(c) != set.end()) {
                    result.push_back({nums[i], nums[j], c});
                    set.erase(c);// 三元组元素c去重
                } else {
                    set.insert(nums[j]);
                }
            }
        }
        return result;
    }
};

2、双指针

「其实这道题目使用哈希法并不十分合适」，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码。

而且使用哈希法 在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是O(n^2)，也是可以在leetcode上通过，但是程序的执行时间依然比较长 。

接下来我来介绍另一个解法：双指针法，「这道题目使用双指针法 要比哈希法高效一些」，那么来讲解一下具体实现的思路。

拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下表0的地方开始，同时定一个下表left 定义在i+1的位置上，定义下表right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i] b = nums[left] c = nums[right]。

接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下表就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

时间复杂度：O(n^2)。

双指针法C++代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int i,left,right;
        int sum;
        vector<vector<int>> res;//直接这样写即可
        sort(nums.begin(),nums.end());//注意要先排序
        // 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for(i=0;i<nums.size();i++){
             // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) {
                return res;
            }
            // 错误去重方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }
            */
            // 正确去重方法，注意还要进行去重，i-1
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            left=i+1;
            right=nums.size()-1;
            while(left<right){
                // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                /*
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;
                */
                sum=nums[i]+nums[left]+nums[right];
                if(sum>0){
                    right--;
                }
                if(sum<0){
                    left++;
                }
                if(sum==0){
                    res.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 res;
    }
};

注意多理解一下这种方法，注意去重的方法以及放的位置。

例题：四数之和

（同一个数组中找几数之和用双指针法，不同数组可以用哈希法来完成）

第18题. 四数之和
题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

「注意：」
答案中不可以包含重复的四元组。

示例：
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

思路：

四数之和，和三数之和是一个思路，都是使用双指针法, 基本解法就是在三数之和 的基础上再套一层for循环。

但是有一些细节需要注意，例如：不要判断nums[k] > target 就返回了，三数之和 可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。（大家亲自写代码就能感受出来）

三数之和的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下表作为双指针，找到nums[i] + nums[left] + nums[right] == 0。

四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下表作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n^{2)，四数之和的时间复杂度是O(n}3) 。

那么一样的道理，五数之和、六数之和等等都采用这种解法。

对于三数之和双指针法就是将原本暴力O(n^{3)的解法，降为O(n}2)的解法，四数之和的双指针解法就是将原本暴力O(n^{4)的解法，降为O(n}3)的解法。

之前我们讲过哈希表的经典题目：四数相加II，相对于本题简单很多，因为本题是要求在一个集合中找出四个数相加等于target，同时四元组不能重复。

而四数相加II是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于本题还是简单了不少！

大家解决一下这两道题目就能感受出来难度的差异。

代码：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> res;
        for(int i=0;i<nums.size();i++){
            //去重
            if(i!=0&&nums[i]==nums[i-1]){
                continue;
            }
            //注意这里j的范围是i+1到nums.size()-1
            for(int j=i+1;j<nums.size();j++){
                //去重,注意是if
                if(j>i+1&&nums[j]==nums[j-1]){
                    continue;
                }
                int sum=nums[i]+nums[j];
                int left=j+1;
                int right=nums.size()-1;
                while(left<right){
                    if(sum+nums[left]+nums[right]<target){
                        left++;
                    }
                    else if(sum+nums[left]+nums[right]>target){
                        right--;
                    }
                    else{
                        res.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});
                        while(left<right&&nums[left]==nums[left+1])
                            left++;
                        while(left<right&&nums[right]==nums[right-1])
                            right--;
                        // 找到答案时，双指针同时收缩
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }
};

注意要进行两次去重，同时j的范围是i+1到 nums.size()-1

五、总结

「一般来说哈希表都是用来快速判断一个元素是否出现集合里」。

对于哈希表，要知道「哈希函数」和「哈希碰撞」在哈希表中的作用.

哈希函数是把传入的key映射到符号表的索引上。

哈希碰撞处理有多个key映射到相同索引上时的情景，处理碰撞的普遍方式是拉链法和线性探测法。

接下来是常见的三种哈希结构：

• 数组
• set（集合）
• map（映射）

哈希表经典题目

• 数组作为哈希表
  一些应用场景就是为数组量身定做的。但是数组的大小是受限的！题目包含小写字母，那么使用数组来做哈希最合适不过。
  本题和哈希表：有效的字母异位词很像，哈希表：有效的字母异位词是求 字符串a 和 字符串b 是否可以相互组成，在哈希表：赎金信中是求字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a。
  一些同学可能想，用数组干啥，都用map不就完事了。
  「上面两道题目用map确实可以，但使用map的空间消耗要比数组大一些，因为map要维护红黑树或者符号表，而且还要做哈希函数的运算。所以数组更加简单直接有效！」
• set作为哈希表
  这道题目没有限制数值的大小，就无法使用数组来做哈希表了。
  「主要因为如下两点：」
  1、数组的大小是有限的，受到系统栈空间（不是数据结构的栈）的限制。
  2、如果数组空间够大，但哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。
  所以此时一样的做映射的话，就可以使用set了。
  关于set，C++ 给提供了如下三种可用的数据结构：（详情请看关于哈希表，你该了解这些！）
  std::set
  std::multiset
  std::unordered_set
  std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希， 使用unordered_set 读写效率是最高的，本题并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。
  在哈希表：快乐数中，我们再次使用了unordered_set来判断一个数是否重复出现过。
• map作为哈希表
  来说一说：使用数组和set来做哈希法的局限。

数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下表位置，因为要返回x 和 y的下表。所以set 也不能用。
map是一种<key, value>的结构，本题可以用key保存数值，用value在保存数值所在的下表。所以使用map最为合适。

C++提供如下三种map：：（详情请看关于哈希表，你该了解这些！）

std::map
std::multimap
std::unordered_map
std::unordered_map 底层实现为哈希，std::map 和std::multimap 的底层实现是红黑树。

同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解），哈希表：两数之和中并不需要key有序，选择std::unordered_map 效率更高！

在哈希表：四数相加II中我们提到了其实需要哈希的地方都能找到map的身影。

本题咋眼一看好像和18. 四数之，15.三数之和差不多，其实差很多！

「关键差别是本题为四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑重复问题，而18. 四数之，15.三数之和是一个数组（集合）里找到和为0的组合，可就难很多了！」

用哈希法解决了两数之和，很多同学会感觉用哈希法也可以解决三数之和，四数之和。

其实是可以解决，但是非常麻烦，需要去重导致代码效率很低。

在哈希表：解决了两数之和，那么能解决三数之和么？中我给出了哈希法和双指针两个解法，大家就可以体会到，使用哈希法还是比较麻烦的。

所以18. 四数之，15.三数之和都推荐使用双指针法！