最接近的三数之和，完整代码实现，java及python实现。

2. 最接近的三数之和

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
示例 2：

输入：nums = [0,0,0], target = 1
输出：0

• 思路

  排序+双指针。先将数组排序，先枚举数组元素作为第一个数a，剩下的b和c用双指针找出。具体的，pb指向数a的下一个数，pc指向末尾。如果a+b+c>=target,则pc向左移动，反之，pb向右移动。在这个过程中不断地更新差值的最小绝对值。
  trick：跳过相同的元素，在a+b+c==target时返回。
  

• java实现

  package com.lxs.controller;
  
  import java.util.Arrays;
  
  public class Hello {
      public static void main(String[] args) {
          int[] nums = {-1,2,1,-4};
          System.out.println(threeSumColest(nums,1));
      }
      public static  int threeSumColest(int[] nums,int target){
          Arrays.sort(nums);
          int n = nums.length;
          int best = 10000000;
          //枚举a
          for (int i = 0; i < n; i++) {
              if (i > 0 && nums[i] == nums[i-1]){
                  continue;
              }
              int pb = i+1;
              int pc = n-1;
              //使用双指针枚举b和c
              while (pb < pc){
                  int sum = nums[i] + nums[pb] + nums[pc];
                  //不断的更新b和c的值
                  if (Math.abs(sum - target) < Math.abs(best - target)){
                      best = sum;
                  }
                  if (sum == target){
                      return 0;
                  }
                  if (sum >= target){
                      int j = pc - 1;
                      //移动到下一个不相等的元素
                      while (j > pb && nums[j] == nums[pc]  ){
                          j--;
                      }
                      pc = j;
                  }else {
                      int k = pb + 1;
                      //移动到下一个不相等的元素
                      while (k < pc && nums[k] == nums[pb]){
                          k++;
                      }
                      pb = k;
                  }
              }
          }
          return best;
      }
  }
  
  

• python实现

  class Solution:
      def threeSumClosest(self, nums: List[int], target: int) -> int:
          nums.sort()
          n = len(nums)
          best = 10**7
          
          # 根据差值的绝对值来更新答案
          def update(cur):
              nonlocal best
              if abs(cur - target) < abs(best - target):
                  best = cur
          
          # 枚举 a
          for i in range(n):
              # 保证和上一次枚举的元素不相等
              if i > 0 and nums[i] == nums[i - 1]:
                  continue
              # 使用双指针枚举 b 和 c
              j, k = i + 1, n - 1
              while j < k:
                  s = nums[i] + nums[j] + nums[k]
                  # 如果和为 target 直接返回答案
                  if s == target:
                      return target
                  update(s)
                  if s > target:
                      # 如果和大于 target，移动 c 对应的指针
                      k0 = k - 1
                      # 移动到下一个不相等的元素
                      while j < k0 and nums[k0] == nums[k]:
                          k0 -= 1
                      k = k0
                  else:
                      # 如果和小于 target，移动 b 对应的指针
                      j0 = j + 1
                      # 移动到下一个不相等的元素
                      while j0 < k and nums[j0] == nums[j]:
                          j0 += 1
                      j = j0
  
          return best
  
  作者：LeetCode-Solution
  链接：https://leetcode-cn.com/problems/3sum-closest/solution/zui-jie-jin-de-san-shu-zhi-he-by-leetcode-solution/
  来源：力扣（LeetCode）
  著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。