LeetCode:三数之和/最接近的三数之和

题目：
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

思路：
这道题用暴力法三层嵌套for循环的时间复杂度太高，不可取。
应该思考这三个数满足的特征，以此来限制条件减少循环次数。

以0为分界，三个数中全为0或有正有负才行。
由此就要考虑，先排序成有序数组。选定一个数为c位，用双指针前后寻找剩下满足条件的两个数。

1.什么情况下不存在满足条件数组
元素个数<3； 排序后的尾部元素<0; 排序后的首部元素>0 。
return
2. 选哪个数据为中值参照？
以左边元素为参照，在它后面的序列中选择符合条件的左右值。
(1) 参照元素>0时，后面全大于0, 查找结束.break
(2)参照元素重复时，应跳过该元素，continue
(3) 定义好左右指针
求sum
sum =0 ,push_back（{}），l++，r–
sum <0 ,l++
sum > 0，r–
碰到相邻的重复元素，也应跳过。
3.查找结束，返回存储容器。

    vector<vector<int>> threeSum(vector<int>& nums) {
        int len=nums.size();
        vector<vector<int>>res;
        res.clear();
        sort(nums.begin(),nums.end());
        if(len<3||nums[0]>0||nums[len-1]<0)
            return res;
        for(int i=0;i<len-2;i++)
        {
            if(nums[i]>0)
                break;
            if(i>0&&(nums[i]==nums[i-1]))continue;            
            int left = i + 1;
            int right = len - 1;
            while(left < right )
            {
                int sum = nums[i] + nums[left]+nums[right];
                if(sum == 0)
                {
                   // vector<int> tmp;
                   // tmp.push_back(nums[i]);
                   // tmp.push_back(nums[left]);
                   // tmp.push_back(nums[right]);
                   // res.push_back(tmp);
                    res.push_back({nums[i],nums[left],nums[right]});
                    left++;
                    right--;
                    while(left<right&&(nums[left]==nums[left-1]))left++;
                    while(left<right&&(nums[right]==nums[right+1]))right--;
                }
                else if(sum<0)
                {
                    left++;
                     while(left<right&&(nums[left]==nums[left-1]))left++;
                }
                else
                {
                    right--;
                    while(left<right&&(nums[right]==nums[right+1]))right--;
                }               
            }
        }
        return res;
    }

类似的题有最接近的三数之和 ：
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

还是卡边界处理了特定情况后处理一般情况
用一个Min值来控制是否记录最接近的值。

    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        int res=0,min = INT_MAX;
        int len = nums.size();
        if(len<=3)
        {
            for(int i=0;i<len;i++)
                res+=nums[i];
            return res;
        }
        if((nums[0]+nums[1]+nums[2])>target)
            return nums[0]+nums[1]+nums[2];
        else if((nums[len-1]+nums[len-2]+nums[len-3])<target)
            return nums[len-1]+nums[len-2]+nums[len-3]; 
        else
        {
            for(int i=0;i<len-2;i++)
            {
                int left=i+1;
                int right = len-1;
                if((nums[i]+nums[i+1]+nums[i+2])>target)
                {
                     if((nums[i]+nums[i+1]+nums[i+2]-target)<min)
                        res = nums[i]+nums[i+1]+nums[i+2];
                     break;
                }                    
                else if( (nums[i]+nums[len-1]+nums[len-2]) <target)
                {
                     if( target-(nums[i]+nums[len-1]+nums[len-2]) < min)
                     {
                         res = nums[i]+nums[len-1]+nums[len-2];
                         min = target-(nums[i]+nums[len-1]+nums[len-2]);
                     }
                }                    
                else
                {
                    while(left<right)
                    {
                         int sum = nums[i]+nums[left]+nums[right];
                         if(sum == target)
                            return target;
                         else if(sum < target)
                         {
                             left++;
                         }
                        else
                        {
                            right--;
                        }
                        if(abs(sum-target)<min)                         
                        {
                            res = sum;
                            min = abs(sum-target);
                        }
                    }                 
                }
            }
        }
        return res;   
    }