代码随想录02_977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II ，总结

uncle_q_

已于 2022-12-29 21:08:27 修改

阅读量386

点赞数

分类专栏： leetcode 文章标签： leetcode 算法数据结构

于 2022-12-29 21:07:48 首次发布

本文链接：https://blog.csdn.net/uncle_q_/article/details/128487984

版权

leetcode 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II ，总结

1.有序数组的平方

977. 有序数组的平方 - 力扣（LeetCode）

给你一个按 非递减顺序 排序的整数数组 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]

思路

这里最重要的信息是非递减顺序，即原数组已经排序过了，针对有序数组比较方便使用双指针的思想

这里需要新开辟一个数组用来盛放最终的结果

在本题中，需要理解的一点是，两端的数字在平方之后会变大，所以如果想新生成的数组是有序的话，两个指针是从原数组的两端往中间走，不断比较两者的大小，大的就放到新数组里，然后新数组的下标不断往前走

i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

请添加图片描述

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0,right=nums.length-1;
        int idx = nums.length-1;
        int []res = new int [nums.length];
        while(left<=right){
            if(nums[left]*nums[left] < nums[right]*nums[right]){
                res[idx] = nums[right]*nums[right];
                idx--;
                right--;
            }
            else{//此种情况下包含left=right的情况
                res[idx] = nums[left]*nums[left];
                idx--;
                left++;
            }
        }
        return res;
    }
}

2.长度最小的子数

209. 长度最小的子数组 - 力扣（LeetCode）

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

示例：

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

思路

因为本题要求找一个连续子数组，所以本题用到的一个思想是滑动窗口，用到的也是两个循环，不过这两个循环并不是无脑遍历，而是带有触发条件的更新，也可以理解为用一个循环干两个循环的事情。

这里的思想可以理解为，我去寻找的数组里某一段的数值的和，当这个和大于等于s的数值就说明这个区段是存在这样一个连续子数组的（因为有可能不能存在符合条件的子数组，所以不能将while循环的条件设为大于）

实现上来说，定住左边的指针，右边那个指针是不断地往右走，算中间的算术和，然后发现这个和大于等于s的时候，左边的指针开始往右挪动，并且这个算术和需要减掉之前挪走的数值

请添加图片描述

其实从动画中可以发现滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动，所以叫做滑动窗口更适合一些。

在本题中实现滑动窗口，主要确定如下三点：

窗口内是什么？
如何移动窗口的起始位置？
如何移动窗口的结束位置？

窗口就是满足其和 ≥ s 的长度最小的连续子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

解题的关键在于窗口的起始位置如何移动，如图所示：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;// 滑动窗口起始位置
        int n = nums.length;
        int sum = 0;// 滑动窗口数值之和
        int len = Integer.MAX_VALUE;//滑动窗口的长度，我们要找一长度最小的
        for(int right = 0; right < n; right++){
            sum = sum + nums[right];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while(target <= sum){
                len = Math.min(len, right-left+1);// right-left+1取子序列的长度
                sum = sum-nums[left];// 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
                left++;
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return len == Integer.MAX_VALUE ? 0 : len;
    }
}

3. 螺旋矩阵II

59. 螺旋矩阵 II - 力扣（LeetCode）

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ZXYebuW-1672318958771)(https://assets.leetcode.com/uploads/2020/11/13/spiraln.jpg)]

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

思路

本题解法最大的一个突破点就是，突破了传统循环只能从左往右走，下标只能越来越大的传统套路，而是你是可以控制下标更新的方向。

从实现上来说，关键是理清每次循环开始结束的边界，因为你要从这个矩阵一圈一圈的往里走，这里用的是左闭右开的思路：相同颜色的色块为一次循环中遍历的元素。

所以代码就是一个大循环控制你要走几圈，然后每次循环遍历每一圈的四条边，最后，如果你是奇数行的话，把最后一个值赋给中间的元素就好

class Solution {
    public int[][] generateMatrix(int n) {
        int start_x = 0,start_y = 0;//每一圈开始的起点
        int count = 1;//用来给每个元素赋值
        int t = 0;//用来控制大循环的次数，也就是要走几圈
        int [][] mtrx = new int[n][n];//最终生成的矩阵
        int i = 0, j = 0;//下标的初始值
        int offset = 1;//偏移量，因为随着圈数的更新，你不能每条边都走到n
        while(t < n/2){
            for(j = start_y; j < n-offset; j++){
                mtrx[start_x][j] = count;//注意此处不能写为mtrx[i][j] 因为此时涉及i的更新，如果走完一圈，此时i还没有更新为最新的start_x
                count++;
            }
            for(i = start_x; i < n-offset; i++){
                mtrx[i][j] = count;
                count++;
            }
            for(;j > start_y;j--){
                mtrx[i][j] = count;
                count++;
            }
            for(;i > start_x;i--){
                mtrx[i][j] = count;
                count++;
            }
            offset++;
            start_x++;
            start_y++;
            t++;
        }
        if(n % 2 == 1){
            mtrx[start_x][start_y] = count;
        }
        return mtrx;
    }
}

总结

二分法
- 二分法感觉最重要的场景是一个序列是有序的情况，在用的时候，关键是要掌握数组表示的边界，是左闭右开还是左闭右闭，同样数组边界的表示方法也关系到，循环条件的边界，是小于等于还是小于，是right还是right-1
双指针
- 双指针也更多是针对一个有序的序列，本质是通过已经有序的信息，降低无目的的遍历
滑动窗口
- 滑动窗口最关键的是连续，当你需要找一个连续空间的时候，可以使用滑动窗口的思想
模拟行为
- 对于我来说，模拟行为最重要的是突破了之前我认为的，循环只能从小到大从左往右来的传统思想，而是你可以控制下标的走向，只要你设定好初始值的更新。