Leetcode JAVA刷刷站（16）最接近的三数之和

一、题目概述 

二、思路方向 

       为了解决这个问题，我们可以使用双指针法结合排序。首先，对数组 nums 进行排序，然后使用三层嵌套循环来遍历所有可能的三元组（三个数的组合）。但是，这种方法的时间复杂度会非常高，为 O(n^3)，对于大数据集来说是不可接受的。

       由于数组已排序，我们可以优化这个过程，使用双指针法来减少时间复杂度。思路是，固定一个数（外层循环），然后使用两个指针（一个在前，一个在后）在剩下的数中移动，以找到和最接近 target 的三个数。

三、代码实现 

import java.util.Arrays;  
  
public class Solution {  
    public int threeSumClosest(int[] nums, int target) {  
        Arrays.sort(nums); // 首先对数组进行排序  
        int closestSum = nums[0] + nums[1] + nums[2]; // 初始化最接近的和为数组中的前三个数的和  
        int n = nums.length;  
  
        for (int i = 0; i < n - 2; i++) {  
            // 避免重复计算相同的第一个数  
            if (i > 0 && nums[i] == nums[i - 1]) {  
                continue;  
            }  
            int left = i + 1;  
            int right = n - 1;  
  
            while (left < right) {  
                int sum = nums[i] + nums[left] + nums[right];  
                  
                // 更新最接近的和  
                if (Math.abs(sum - target) < Math.abs(closestSum - target)) {  
                    closestSum = sum;  
                }  
  
                if (sum < target) {  
                    left++;  
                } else if (sum > target) {  
                    right--;  
                } else {  
                    // 如果找到和为目标值的三个数，直接返回（题目假定每组输入只存在恰好一个解，但此处为通用解）  
                    return sum;  
                }  
  
                // 避免重复计算相同的两个数  
                while (left < right && nums[left] == nums[left + 1]) left++;  
                while (left < right && nums[right] == nums[right - 1]) right--;  
            }  
        }  
  
        return closestSum;  
    }  
  
    public static void main(String[] args) {  
        Solution solution = new Solution();  
        int[] nums = {-1, 2, 1, -4};  
        int target = 1;  
        System.out.println(solution.threeSumClosest(nums, target)); // 输出 2  
    }  
}

执行结果： 

四、小结

       这个解决方案的时间复杂度是 O(n^2)，其中 n 是数组 nums 的长度。这是因为我们有一个固定元素的循环（O(n)），以及在内部有两个指针的循环（最坏情况下为 O(n)）。空间复杂度主要是排序所需的 O(log n)（如果使用高效的排序算法，如快速排序、归并排序等，在平均和最好情况下）或 O(n)（如果使用如冒泡排序这样的简单算法），以及存储结果的 O(1) 空间。然而，Java 的 Arrays.sort() 方法通常是基于快速排序或归并排序的，所以我们可以认为排序的空间复杂度为 O(log n)（但需要注意，在某些情况下，如完全逆序的数组，快速排序的栈空间可能会达到 O(n)）。在大多数实际应用中，我们可以将其视为 O(log n) 或忽略不计，因为这不是算法中的主要空间复杂度部分。

 结语  

人生就像一场旅行

不必急于到达目的地

沿途的风景同样值得珍惜

！！！