leetCode-两数之和，三数之和，四数之和

两数之和

传送门：LeetCode - 1 两数之和.

根据题意，我们可以轻松的想到一个O(n^2) 的一个做法，双层循环就可以。但是我们是不是会有更好的方法来优化这个时间复杂度呢，诶，先排序然后使用双指针就可以将时间复杂度优化到O(nlogn) 这是一个进步，如何将它优化到一个O(n) 的做法呢，接下来，我们来一起看一看

通过上图，我们分析可以得知，只需要找到在s[i] 前面是否满足存在一个数字为target - s[i]。 这样的话，我们就可以使用哈希表来做，在STL中有map 和 unordered_map ,map是O(logn) 的而unordered_map 是O(1)的.所以我们就可以使用unordered_map 。

我们可以定义一个哈希表来存储第i个数字之前的数字的target - s[0 ~ i - 1]。然后进行检索。最后我们可以发现，哈希表的插入删除均为O(1)的操作，故而最后的时间复杂度为O(n).

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
         unordered_map<int ,int> heap;
         for(int i = 0; i < nums.size();i++){
             int temp = target - nums[i]; // 要查询的数字
             if(heap.count(temp)){ //如果temp存在，说明找到
                 return {heap[temp],i}; //返回temp数对应的下标和i
             }
             heap[nums[i]] = i;
         }   
         return {};
    }
};

三数之和

题目传送门 ：LeetCode-15 三数之和

此类题可以使用双指针和哈希表来解答。但是虽然两种方法的时间复杂度相同但是哈希表的空间复杂度会大于双指针，所以推荐使用双指针的做法。
做法：

根据上图，我们先将数组进行排序，排序以后再用双指针的做法，先固定一个i ,再对j,k使用双指针，这样子就可以优化掉暴力做法的一重循环。j,k的时间复杂度加起来也就是2*n ，所有最后的时间复杂度就是O(n^2) 的.
由于需要去重，当 i 和 i - 1 个元素相等就可以跳过，因为相邻相等的元素的方案会是相同的。同理 当j 和 j - 1的元素相等是，也跳过

class Solution {
public:
   vector<vector<int>> threeSum(vector<int>& nums) {
       vector<vector<int>> res;
       sort(nums.begin(),nums.end());
       for(int i = 0; i < nums.size(); i++ ){
           if(i && nums[i] == nums[i - 1]) continue;
           for(int j = i + 1 ,k = nums.size() - 1; j < k ;j++ ){
               if(j > i + 1 && nums[j] == nums[j - 1])continue;
               while(j < k - 1 && nums[j] + nums[k - 1] + nums[i] >= 0) k--;
               if(nums[i] + nums[j] + nums[k] == 0){
                   res.push_back({nums[i],nums[j],nums[k]});
               }
           }
       }
       return res;
   }
};

四数之和

题目传送门 : leetCode - 18 四数之和
算法分析
排序 + 双指针

1、与三数之和操作类似，先枚举每两个数，表示该数nums[i]和nums[j]已被确定，在排序后的情况下，通过双指针l，r分别从左边l = i + 1和右边n - 1往中间靠拢，找到nums[i] + nums[j] + nums[l] + nums[r] == target的所有符合条件的搭配
2、在找符合条件搭配的过程中，假设sum=nums[i] + nums[j] + nums[l] + nums[r]
若sum > target，则r往左走，使sum变小
若sum < target，则l往右走，使sum变大
若sum == target，则表示找到了与nums[i]搭配的组合nums[l]和nums[r]，存到ans中
3、判重处理
确定好nums[i]时，l 需要从i + 1开始
当nums[i] == nums[i - 1]，表示当前确定好的数与上一个一样，需要直接continue
当nums[j] == nums[j - 1]，表示当前确定好的数与上一个一样，需要直接continue
当找符合条件搭配时，即sum == 0,需要对相同的nums[l]和nums[r]进行判重出来

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
       
        vector<vector<int> > res;
         if(nums.size() == 0) return res;
        sort(nums.begin(),nums.end());
        for(int i = 0; i < nums.size()-1; i ++ ){
            if(i && nums[i] == nums[i- 1])continue;
            for(int j = i + 1; j < nums.size(); j ++){
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;
                for(int k = j + 1, l = nums.size() - 1; k < l; k ++){
                    if(k > j + 1 && nums[k] == nums[k - 1]) continue;
                    while(l-1 > k && nums[i] + nums[j] + nums[k] + nums[l-1] >= target) l--;
                    if(nums[i] + nums[j] + nums[k] + nums[l] == target){
                        res.push_back({nums[i] , nums[j] , nums[k] , nums[l]});
                    }
                }
            }
        }
        return res;
    }
};

以上就是两数之和，三数之和，四数之和，使用的方法是排序 + 双指针，双指针的使用是因为使用双指针可以优化掉一层循环，来提高程序的效率，降低时间复杂度