leetcode 三数之和

给你一个整数数组 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] 。

注意，输出的顺序和三元组的顺序并不重要。

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/3sum

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

#pragma once
#include<iostream>;
#include<vector>;
#include "main.h"
#include<algorithm>
using namespace std;

vector<vector<int>> ThreeSum::threeSum(vector<int>& nums)
{
    /*
    * 1. 排序法进行，如果第一位大于0或者末尾小于0，无解
    * 2.数组元素总数小于3，无解
    * 3.排序后注意其中重复元素，选择跳过
    * 4.原理上遍历数组，第一个数+后面的数（嵌套循环），与最末尾的数作差，小于0则第二轮循环数字右移，小于0则末尾数字左移，等于0输出结果。
    */
    sort(nums.begin(), nums.end());
    int n = nums.size();
    vector<vector<int>> result;

    if (nums[0] > 0 || nums[n - 1] < 0 || n<3) 
    {
        return {};
    }


    for (int i = 0; i < n - 2; i++) 
    {
        int left = i+1;
        int right = n - 1;

        if (i > 0 && nums[i] == nums[i - 1]) continue;
        //为什么我直接判断当前 i 和 left 相等则continue会漏掉数据。
        //nums1 = { -1,0,1,2,-1,4 }; 排序后{-1，-1,0,1,2,4}
        //if (nums[i] == nums[left])  //此时判断的是当前nums[i] 和 
        //正在移动的左指针的值相等，即-1和-1是相等，直接跳出循环使得i从1开始，
        //这时候初始值从第一个-1跳过，变为第二个-1，就从一开始就不会出现两个-1的情况。
        //当第二个-1出现时，因为带-1 的结果已经在第一次全部出现，避免重复结果，选择跳过。

        while (left < right)
        {
            if (nums[i] + nums[left] + nums[right] == 0)
            {
                vector<int> sub_result;
                // 将三元组存入子数组
                sub_result.clear();
                sub_result.push_back(nums[i]);  //使用emplace_back会更快
                sub_result.push_back(nums[left]);
                sub_result.push_back(nums[right]);

                // 将子数组存入结果三元组数组
                result.push_back(sub_result);
                left ++;
                right--;  
                //为什么出现结果后直接选择双指针双跳？ 双跳和单跳的结果一样，但是因为排序
                //处理，双跳速度更快。 因为第二层循环里，是在右移left指针，数字逐渐变
                //大，意味着nums[i]+nums[left]会变大（负数变大），一定不会再是刚刚已经
                //确定结果的right指针位置的数，而是right左移变小的数。
                while (left < right && nums[left] == nums[left-1])
                {
                    left++;
                }
                //while (left < right && nums[right] == nums[right+1])
                //{
                //    right--;
                //}

            }
            else if (nums[i] + nums[left] + nums[right] < 0)
            {
                left++;
            }
            else if (nums[i] + nums[left] + nums[right] > 0)
            {
                right--;
            }
         }

    }

    return result;
}



//系统推荐答案，采取对vector数据的迭代器读取操作。原理上一致
vector<vector<int>> ThreeSum::threeSum(vector<int>& nums) {
    vector<vector<int>> ret;
    vector<int> result(3);
    if (nums.size() < 3 || nums.empty())
    {
        return ret;
    }
    sort(nums.begin(), nums.end());
    for (vector<int>::iterator i = nums.begin(); i < nums.end(); i++)//最起码三个数
    {
        vector<int>::iterator left = i + 1;
        vector<int>::iterator right = nums.end() - 1;
        if (*i > 0)//已排序，最小的数也比0大。
        {
            break;
        }
        if (distance(nums.begin(), i) > 0 && *i == *(i - 1))
        //重复的数不重复，问题在这里 i=0解引用出错
        {
            continue;
        }
        while (left < right)
        {
            if (*i + *left + *right == 0)
            {
                result.clear();
                result.push_back(*i);
                result.push_back(*left);
                result.push_back(*right);
                ret.push_back(result);
                left++;
                right--;
                while (*right == *(right + 1) && left < right)
                {
                    right--;
                }
                while (*left == *(left - 1) && left < right)
                {
                    left++;
                }
            }
            else if (*i + *left + *right > 0)
            {
                right--;
            }
            else if (*i + *left + *right < 0)
            {
                left++;
            }
        }
    }
    return ret;
}

//测试
int main()
{
//三数之和

    ThreeSum ThreeSum;
    vector <int> nums1 = { -1,0,1,2,-1,4 };

    vector<vector<int>> res;
    res = ThreeSum.threeSum(nums1);

    for (auto i : res) 
    {
        for (auto j : i) 
        {
            cout << j << " " ;
        }
        cout << "\t" << endl;
    }
    
    return 0;
}