Leetcode-talk05最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

Python:
排序+双指针
算法流程：
特判，对于数组长度nn，如果数组为Null或者数组长度小于3，返回[][]。
对数组进行排序，并定义resres，保存最接近和。
遍历排序后数组：
对于重复元素，跳过，避免重复计算（也可以不跳过）
令左指针L=i+1L=i+1,右指针R=n-1R=n−1,当L<RL<R时，执行循环：
**cur_sum=nums[i]+nums[L]+nums[R],cur_sum=target,返回target
*abs(cur_sum-target)<abs(res-target),说明cur_sumcur_sum更接近目标，更新resres
*若cur_sum-targetcur_sum−target大于0，说明nums[R]nums[R]太大，RR左移
若cur_sum-targetcur_sum−target小于0，说明nums[L]nums[L]太小，LL右移

代码

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        n=len(nums)
        if(not nums or n<3):
            return None
        nums.sort()
        res=float("inf")
        for i in range(n):
            if(i>0 and nums[i]==nums[i-1]):
                continue
            L=i+1
            R=n-1
            while(L<R):
                cur_sum=nums[i]+nums[L]+nums[R]
                
                if(cur_sum==target):
                    return target
                if(abs(cur_sum-target)<abs(res-target)):
                    res=cur_sum
                if(cur_sum-target<0):
                    L+=1
                else:
                    R-=1
        return res

C++:

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        int min = INT_MAX;
        int result;
        if(nums.empty()) return 0;
        sort(nums.begin(), nums.end());
       
        for(int i = 0; i < nums.size(); i++) {
            int fix = nums[i];
            if(i > 0){
                if(nums[i] == nums[i-1]) continue;
            }
            int left = i+1;
            int right = nums.size()-1;
            while(left < right) {
                if(nums[left]+nums[right]+fix == target  ){
                    return target;                                
                } else if(nums[left]+nums[right]+fix > target){   
                    int tmp = nums[left]+nums[right]+fix-target;
                    if(min > tmp){
                        min = tmp;
                        result = tmp+target;
                    }
                    right--;                    
                } else {
                    int tmp = target - (nums[left]+nums[right]+fix);
                    if (min > tmp){
                        min = tmp;
                        result = target-tmp;
                    }
                    left++;                    
                }
            }
        }
        return result;
    }
};