【java算法专场】双指针（下）

小猪同学hy

已于 2024-08-07 00:12:19 修改

阅读量466

点赞数 10

分类专栏：算法成神之路文章标签：算法 java 数据结构

于 2024-07-10 13:39:30 首次发布

本文链接：https://blog.csdn.net/zhyhgx/article/details/140317854

版权

算法成神之路专栏收录该内容

10 篇文章 1 订阅

订阅专栏

611. 有效三角形的个数

算法思路

算法代码

/**
     * 计算可能的三角形数量。
     *
     * @param a 一个整数数组，数组中的元素代表三角形的边长。
     * @return 返回可能构成的三角形的数量。
     */
    public int triangleNumber(int[] a) {
        // 如果数组为空，则无法构成任何三角形
        if(a.length==0) return 0;

        // 对数组进行排序，以便后续通过比较边长来判断是否可以构成三角形
        Arrays.sort(a);//给数组排序

        // 初始化计数器，用于记录可以构成的三角形的数量
        int count=0;// 用来计算三角形个数

        // 从最长的边开始检查，逐步减少边长，以找到所有可能的三角形组合
        int n= a.length-1;
        while(n>=2){
            // 使用双指针技术，左指针指向最短边，右指针指向最长边，中间的边长由数组排序决定
            int left=0;
            int right=n-1;
            while(left<right){
                // 如果当前选择的三条边满足构成三角形的条件，则增加计数器，并移动右指针
                // 如果a+b大于c，那么此时可以构成三角形，且在【left，right】内的所有情况都可以构成三角形
                //count+=right-left，right--
                if(a[left]+a[right]>a[n]){
                    count+=right-left;
                    right--;
                }else{
                    // 如果不满足条件，则移动左指针，尝试其他可能的边长组合
                    // 如果a+b小于c，那么此时无法构成三角形，让left++
                    left++;
                }
            }
            // 检查完一组边长后，减少最长边的长度，继续检查下一组
            //当判断完后，让n--
            n--;
        }
        // 返回可以构成的三角形的总数量
        return count;
    }

LCR 179. 查找总价格为目标值的两个商品

算法思路

算法代码

HashSet

 public int[] twoSum(int[] price, int target) {
         Set<Integer> set=new HashSet<>();
         int i=0;
         for(;i<price.length;i++){
             if(set.contains(target-price[i])){
                 return new int[]{target-price[i],price[i]};
             }else{
                 set.add(price[i]);
             }
         }
         return new int[]{-1,-1};
    }

双指针

/**
     * 使用双指针方法查找数组中两个数的和等于特定目标值的索引。
     * 这个方法避免了对每个可能的组合进行显式的迭代，通过调整左右指针来缩小搜索范围。
     *
     * @param a 输入的整数数组。
     * @param target 目标值，我们需要找到两个数的和等于这个值。
     * @return 包含这两个数索引的数组。如果不存在这样的两个数，则返回{-1, -1}。
     */
    public int[] twoSum(int[] a, int target) {
        // 初始化左指针为数组的起始位置
        // 利用双指针
        int left = 0;
        // 初始化右指针为数组的结束位置
        int right = a.length - 1;
        // 当左指针小于右指针时，执行循环
        while (left < right) {
            // 计算当前左右指针所指元素的和
            int sum = a[left] + a[right];
            // 如果和大于目标值，移动右指针，减小和
            if (sum > target) {
                right--;
            }
            // 如果和小于目标值，移动左指针，增大和
            else if (sum < target) {
                left++;
            }
            // 如果和等于目标值，返回当前左右指针的索引
            else {
                return new int[]{a[left], a[right]};
            }
        }
        // 如果没有找到合适的组合，返回{-1, -1}
        return new int[]{-1, -1};
    }

15. 三数之和

算法思路

算法代码

    /**
     * 寻找数组中所有不重复的三元组，这些三元组的和为零。
     * 
     * @param nums 输入的整数数组
     * @return 返回一个列表，包含所有和为零的不重复三元组
     */
    public List<List<Integer>> threeSum(int[] nums) {
        // 初始化结果列表
        List<List<Integer>> res = new ArrayList<>();
        // 如果数组长度小于3，无法找到满足条件的三元组，直接返回空列表
        if (nums.length < 3) {
            return res;
        }
        // 初始化指针k，用于遍历数组
        int k = 0;
        // 遍历数组，直到k指向的元素后至少还有两个元素
        for (; k < nums.length - 2;) {
            // 初始化左指针left，指向k后的第一个元素
            int left = k + 1;
            // 初始化右指针right，指向数组最后一个元素
            int right = nums.length - 1;
            // 计算目标值，即要找到的三个数的和，这里取当前k指向的数的相反数
            int target = -nums[k];
            // 当左指针小于右指针时，进行循环
            while (left < right) {
                // 计算当前左指针和右指针指向的数的和
                int sum = nums[left] + nums[right];
                // 如果和大于目标值，说明右指针太靠右，需要向左移动
                if (sum > target) {
                    right--;
                }
                // 如果和小于目标值，说明左指针太靠左，需要向右移动
                else if (sum < target) {
                    left++;
                }
                // 如果和等于目标值，找到了一个满足条件的三元组
                else {
                    // 将这个三元组添加到结果列表中
                    res.add(Arrays.asList(nums[k], nums[left], nums[right]));
                    // 移动左指针和右指针，继续寻找下一个满足条件的三元组
                    left++;
                    right--;
                    // 跳过所有与当前左指针指向的数相同的元素，避免重复
                    while (left < right && nums[left] == nums[left - 1]) {
                        left++;
                    }
                    // 跳过所有与当前右指针指向的数相同的元素，避免重复
                    while (left < right && nums[right] == nums[right + 1]) {
                        right--;
                    }
                }
            }
            // 移动k指针，继续寻找下一个可能的三元组
            k++;
            // 跳过所有与当前k指针指向的数相同的元素，避免重复
            while (k < nums.length - 2 && nums[k] == nums[k - 1]) {
                k++;
            }
        }
        // 返回结果列表
        return res;
    }

18. 四数之和

算法思路

考虑下面这种情况，我们需要给aim使用 long类型，并将target也强转为long

算法代码

 /**
     * 寻找数组中所有不重复的四个数，使得它们的和等于指定的目标数。
     *
     * @param nums 输入的整数数组。
     * @param target 目标和。
     * @return 返回一个列表，包含所有满足条件的四个数的组合。
     */
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        // 如果数组长度小于4，无法找到四个数的组合，直接返回空结果
        if (nums.length < 4) {
            return res;
        }
        Arrays.sort(nums);
        // 双层循环遍历数组，第一层循环选择第一个数，第二层循环选择第二个数
        for(int t=0;t<nums.length-3;){
            for(int k=t+1;k<nums.length-2;){
                // 计算剩余两个数的目标和
                long aim=(long)target-nums[t]-nums[k];
                // 使用双指针法寻找剩余的两个数
                int left=k+1;
                int right=nums.length-1;
                // 当左指针小于右指针时，执行循环
                while(left<right){
                    // 当前两个数的和
                    int sum=nums[left]+nums[right];
                    // 如果当前和小于目标和，左指针右移
                    if(aim>sum) left++;
                    // 如果当前和大于目标和，右指针左移
                    else if(aim<sum) right--;
                    // 如果当前和等于目标和，将四个数的组合添加到结果中
                    else {
                        res.add(Arrays.asList(nums[t],nums[k],nums[left],nums[right]));
                        // 移动左指针和右指针，避免重复组合
                        left++; right--;
                        // 跳过所有与前一个数相同的数，避免重复组合
                        while(left<right && nums[left]==nums[left-1]) left++;
                        while(left<right && nums[right]==nums[right+1]) right--;
                    }
                }
                // 移动第二个数的指针，避免重复组合
                k++;
                while(k<nums.length-2 && nums[k]==nums[k-1]) k++;
            }
            // 移动第一个数的指针，避免重复组合
            t++;
            while(t<nums.length-3 && nums[t]==nums[t-1]) t++;
        }
        return res;
    }

以上就是双指针专题篇的内容，若有不足，欢迎指正~