LeetCode16——最接近的3数之和

最新推荐文章于 2021-03-01 20:39:45 发布

Kyrie2011

最新推荐文章于 2021-03-01 20:39:45 发布

阅读量178

点赞数

CC 4.0 BY-SA版权

分类专栏：算法 Java Algorithm

本文链接：https://blog.youkuaiyun.com/qq_18527763/article/details/90745897

算法同时被 2 个专栏收录

56 篇文章

订阅专栏

Java Algorithm

47 篇文章

订阅专栏

本文介绍了一个算法问题的解决方案，旨在从给定的整数数组中找到三个数，使其和最接近给定的目标值。通过使用排序和双指针技巧，实现了高效的求解方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个包括 n 个整数的数组 nums 和一个目标值 target。找出 nums 中的三个整数，使

得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.

与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        //二分查找的变种，查找最相邻的数字
        //LinkedHashMap<Integer, Integer> hm = new LinkedHashMap<>();
        ArrayList<Integer> lst = new ArrayList<>();
        Arrays.sort(nums);
        /*
        for(int i = 0; i < nums.length - 2; i++){
            for(int j = i+1; j < nums.length - 1; j++){
                for(int k = j+1; k < nums.length; k++){
                    int sum = nums[i] + nums[j] + nums[k];
                    if(!lst.contains(sum))
                        lst.add(sum);
                }
            }
        }
        
        */
        //固定一个值，采用双指针方式
        int sum = nums[0] + nums[1] + nums[2];
        for(int i = 0; i < nums.length - 2; i++){
            int l = i + 1;
            int r = nums.length-1;
            while(l < r){
                int tmp = nums[i] + nums[l] + nums[r];
                sum = Math.abs(tmp- target) > Math.abs(sum - target) ? sum : tmp;
                if(tmp == target){
                    return tmp;
                }else if(tmp > target){
                    r--;
                }else
                    l++;
            }
        }
        return sum;
    }

        /*
        Integer[] arr = lst.toArray(new Integer[lst.size()]);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //二分查找
        int L = 0;
        int R = arr.length-1;
        int mid = 0;
        while(L <= R){
            mid = L + ((R - L) >>> 1);
            if(arr[mid] == target){
                break;
            }else if(mid+1 < arr.length && Math.abs(arr[mid+1] - target) > Math.abs(arr[mid] - target)){
                R = mid - 1;
                
            }else
                 L = mid + 1;
               
        }
        int index = (mid+1 < arr.length && Math.abs(arr[mid+1] - target) < Math.abs(arr[mid] - target)) ? mid+1 : mid;
        return arr[index];

    }*/
}