15.三数之和

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

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

本人解法：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        if (nums.size() < 3)return {};
        sort(nums.begin(), nums.end());
        int i = nums.size() - 1;
        
        vector<vector<int>>res;
        while (i>=0&&nums[i] >= 0)
        {
            int target = 0-nums[i];
            nums.pop_back();
            vector<vector<int>> v1 = twoSum(nums, target);
            if (!v1.empty())
            {
                for (int i = 0; i < v1.size(); i++)
                {
                    //判断res中是否有v1[i]，如果有就不添加
                    if (!isExist(res, v1[i]))res.push_back(v1[i]);
                }
            }
            i--;
        }
        
        return res;
    }

    vector<vector<int>> twoSum(vector<int>& nums,int target)//两数之和
    {
        unordered_set<int> s1;
        vector<vector<int>>ans;
        for (int i = 0; i < nums.size(); i++)
        {
            if (s1.find(target - nums[i]) != s1.end())
            {
                vector<int>tmp;
                tmp.push_back(target - nums[i]);
                tmp.push_back(nums[i]);
                tmp.push_back(0-target);
                ans.push_back(tmp);
            }
            s1.insert(nums[i]);
        }
        return ans;
    }

    bool isExist(vector<vector<int>>&n1, vector<int>test)//判断是否有重复数组
    {
        for (int i = 0; i < n1.size(); i++)
        {
            if (n1[i] == test)return true;
        }
        return false;
    }
};

思路：先将vector数组排序，然后从尾到头遍历，运用两数之和的函数，尾部元素的相反数就是target值，每次运用两数之和时，先将原vector数组最后一个元素弹出，然后放入twosum函数中。

但是算法在遇到有大量元素的数组时，时间运行时间过久。

运用双指针法：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        
        if (nums.size() < 3)return {};
        sort(nums.begin(), nums.end());

        vector<vector<int>>res;
        int i, j, k;
        for (i = 0; i < nums.size()&&nums[i]<=0; i++)
        {
            if (i > 0 && nums[i] == nums[i - 1])continue;//跳过重复元素

            int target = -nums[i];
            for (j = i + 1; j < nums.size(); j++)
            {
                if (j > i + 1 && nums[j] == nums[j - 1])continue;//跳过重复元素

                k = nums.size() - 1;
                while (j<k && nums[j] + nums[k]>target)k--;

                if (j == k)break;
                if (nums[j] + nums[k] == target)
                {
                    res.push_back({ nums[i],nums[j],nums[k] });
                }

            }
        }

        return res;
}

很接近正确解法，但是这里我将k=nums.size()-1放在了j循环里面，所以每一次j循环里还会进行一次时间复杂度为O（N）的循环，因此总的时间复杂度为O（N3）；

改进后：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        
        if (nums.size() < 3)return {};
        sort(nums.begin(), nums.end());

        vector<vector<int>>res;
        int i, j, k;
        for (i = 0; i < nums.size()&&nums[i]<=0; i++)
        {
            if (i > 0 && nums[i] == nums[i - 1])continue;//和上次枚举的数不同

            int target = -nums[i];
            k = nums.size() - 1;
            for (j = i + 1; j < nums.size(); j++)
            {
                if (j > i + 1 && nums[j] == nums[j - 1])continue;//和上次枚举的数不同

                
                while (j<k && nums[j] + nums[k]>target)k--;

                if (j == k)break;//说明没有合适的元素使nums[j]与nums[k]的值等于target,退出循环

                if (nums[j] + nums[k] == target)
                {
                    res.push_back({ nums[i],nums[j],nums[k] });
                }
                //如果进入j++说明nums[j]+nums[k]<target,因此nums[j]要变大
                //为什么k不用重新赋值为nums.size()-1,因为如果nums[j]+nums[nums.size()-1]>target
                //那么nums[j+1]+nums[nums.size()-1]>target肯定也成立，以此类推其他元素也是如此，因此不需要重新赋值
            }
        }
        return res;
    }
};

下面解释一些一开始我不理解的地方：

1.j循环是怎么进行的以及k为什么不用重新赋值

j循环中，若进入了j++，说明nums[j]+nums[k]<target,因此nums[j]要变大；

而再次进入j循环中，k不用重新赋值为nums.size()-1，这是因为：

假设刚刚使nums[j]+nums[k]<target的k为stop，则肯定有nums[j]+nums[stop+1]>target，

而若nums[j+1]!=nums[j]，则nums[j+1]>nums[j]，那么nums[j+1]+nums[stop+1]>target肯定也成立，以此类推stop+2,stop+3,..,nums.size()-1都是如此，因此k不用重新赋值，时间复杂度大大提升。

2.j与k相等时，为什么退出循环

因为j与k相等时，说明nums[j]+nums[k]一直大于target，若继续循环，即j++，由于nums[j+1]>=nums[j]，则nums[j+1]+nums[k]也是会大于target的，所以不会有结果，直接退出循环