三数之和（哈希，双指针）

15. 三数之和 - 力扣（LeetCode）

 方法1：哈希算法（不推荐）

缺点：时间复杂度O（N^2），去重情况复杂

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=0-(a+b);
        for(int i = 0; i < nums.size();i++)
        {
            if(nums[i] > 0)//因为a是小于等于b的，当a大于0时，b与c一定大于0，此时不可能三数和为0
            {
                break;
            }
            if(i > 0 && nums[i] == nums[i - 1])//a去重
            {
                continue;
            }
            unordered_set<int> set;//用来存放c的候选
            //b的选择
            for(int j = i + 1; j < nums.size(); j++)
            {
                //b去重，例子-2,1,1,1...
                if(j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2])
                {
                    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;
    }
};

1.外层是a的循环，可以理解为数学上的组合问题，需要注意的是：

当a大于0时，由于排序是升序的，所以a此时对于b和c也是最小，最小的数都大于0，三数之和不可能等于0；

a的去重问题：判断去重时应该是（i > 0;nums[i] == nums[i - 1]）,避免忽略了0，0，0的情况，

如果去重条件是（nums[i] == nums[i + 1]）,会出现忽略0，0，0的情况；

2.内层是b的循环，需要注意的是b的去重问题：
b这里的去重有些复杂，并不是与a的去重一样（前后相等就去重），举个例子-2，1，1，1

此时a = -2，b = 1（第一个）存入set；接下来a = -2， b = 1（第二个），此时a + b + c = 0，

当a = -2，b = 1（第三个）时，由于-2，1，1组合已经有了，所以就不再需要b = 1的情况了，所以此时开始去重。

方法2：双指针法

时间复杂度：O(N^2),空间复杂度：O(1);便于理解；

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[left];c=nums[right];
        for(int i = 0; i < nums.size(); i++)
        {
            //如果a此时已经大于0，因为此时是有序，所以三数不可能等于0（等于0可以，比如0，0，0）
            if(nums[i] > 0)
            {
                return result;
            }
            //a去重
            if(i > 0 && nums[i] == nums[i - 1])
            {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while(right > left)
            {
                if(nums[i] + nums[left] + nums[right] > 0)
                {
                    right--;
                }
                else if(nums[i] + nums[left] + nums[right] < 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作为a，相当于a = nums[i],  b = nums[left],  c = nums[right].

当nums[i] + nums[left] + nums[right] > 0时，说明大了，变小一点就要使right左移；

当nums[i] + nums[left] + nums[right] < 0时，说明小了，变大一点就要使left右移；