数组算法细节（双指针）

最新推荐文章于 2024-11-10 21:43:58 发布

Morris赵

最新推荐文章于 2024-11-10 21:43:58 发布

阅读量864

点赞数 22

文章标签：算法

本文链接：https://blog.csdn.net/private_yt/article/details/135277358

版权

本文介绍了如何解决LeetCode上的两个问题：有序数组的平方，通过双指针策略保证结果数组的非递减顺序；以及滑动窗口问题，找到满足和大于等于目标值的最小子数组长度。作者提供了Java代码实现和优化策略。

摘要由CSDN通过智能技术生成

摘要：

题目：1.有序数组的平方977. 有序数组的平方 - 力扣（LeetCode）

2.滑动窗口（长度最小的子数组）

3.螺旋矩阵二

1.有序数组的平方：题目是：

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

思路：

由于原数组是有序数组，那么平方以后，最大值一定是在数组的头或者尾。中间的一定是最小的，基于此。用两个指针的方法分别标注头和尾，在用一个index变量从nums.length一直到0，为新数组赋值。复制规则就是i和j谁的位置数值平方大就先放谁然后选择i++或者j--。

解题思路：

循环条件是头指针i<=尾指针j。等于的原因是当头尾指向一块的时候也是要平方放入新数组result中的。

代码奉上：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] result = new int[nums.length];
        for(int i=0;i<result.length;i++){
            result[i] = -1;
        }
        int index = nums.length-1;
        int j =nums.length-1;
        int i=0;
        while(i<=j){
            if(nums[i]*nums[i]>nums[j]*nums[j]){
                result[index--] = nums[i]*nums[i];
                i++;
            }else{
                result[index--] = nums[j]*nums[j];
                j--;
            }
        }
        return result;

    }
}

感觉和快速排序类似，可以留坑，写一个快速排序的思路。

2.滑动窗口（重点）

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

显然用两个for循环，i用来遍历每一个元素，j遍历从i开始的后面的元素，期间判断元素和是不是>=s?记录长度，更新i，重新遍历j。

这样会超时。

那么怎么优化呢？

还是使用双指针，我们在删除元素的题时使用了双指针（实际是快慢指针，快指针for(fast=0;fast<nums.length;fast++),用快指针遍历所有元素，分两种情况：一种是nums[fast]！=target,那么就让快指针元素覆盖慢指针元素，接着slow++(注意，慢指针只有再这个情况是++操作)，下一个情况就是target，这就需要直接下一循环即可，fast掠过他，等slow指向的时候就覆盖了）达到了块更新的效果。

另一个就是上面使用了头尾双指针，用来结合数组数据特性，特殊处理数组两边的数据。类似于快速排序。

思路：

滑动窗口也是用两个指针：关键在于理解怎么优化的？就是理解为什么双指针行？假设i与j已经满足一段子序列大于等于target了，按照暴力就应该i++循环找下一组子序列。这就造成了重复判断：因为i到j这一段已经走过一次了，j不从i+1位置走的话就是优化了。

解题方法：

窗口：i=0,j=0；开始。i为起点，j为终点，

窗口终点如何移动：i到j内的元素和与target相比，大于等于停止。否则j++；

窗口起点如何移动：当i到j内的元素和大于等于target时，i++，就是对应暴力的下一轮了

循环条件：j<nums,length时循环。

循环内部：注意while()这一块，详情看代码

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int i=0;
        int sum = 0;
        int sub =0;
        boolean a = true;
        int result = nums.length;
        for(int j=0;j<nums.length;j++){
            sum+=nums[j];
            while(sum>=target){  //if不好的原因是，不能处理i+1---j内部还大于target情况，而若sum>=target持续，那还应该更新result
                sub = j-i+1;
                result = Math.min(result,sub);  //保留结果
                sum = sum-nums[i];
                i++;
                a= false;
            }//循环结束i-j一定是sum<target
        }
        if(a){
            return 0;
        }
        return result;
    }
}

3.螺旋数组：这个就是考察数组循环的终止条件把握。

class Solution {
    public int[][] generateMatrix(int n) {
        int stratx = 0;
        int i=0;
        int j=0;
        int sum=0;
        int count =1;
        int offset = 0;
        int[][] nums = new int[n][n];
        while(offset++<(n/2))
        {//顶端从左至右
            for(j=stratx;j<n-offset;j++){
                nums[stratx][j] = count++;
            }//右侧从上倒下
            for(i=stratx;i<n-offset;i++){
                nums[i][j] = count++;
            }//底端从右到左
            for(;j>=offset;j--){
                nums[i][j] = count++;
            }//左侧从下到上
            for(;i>=offset;i--){
                nums[i][j] = count++;
            }
            stratx++;
        }//奇数矩阵中间空着，填数；
        if((n%2)==1){
            nums[n/2][n/2] = count++;
        }
        return nums;

    }
}