代码随想录算法训练营第二天|977 有序数组的平方、209 长度最小的子数组、59 螺旋矩阵Ⅱ

最新推荐文章于 2024-09-06 10:38:06 发布

Janice0721

最新推荐文章于 2024-09-06 10:38:06 发布

阅读量499

点赞数

分类专栏：代码随想录训练营文章标签：算法矩阵 leetcode java

本文链接：https://blog.csdn.net/weixin_58285098/article/details/126996062

版权

代码随想录训练营专栏收录该内容

8 篇文章 0 订阅

订阅专栏

代码随想录算法训练营第二天|977 有序数组的平方、209 长度最小的子数组、59 螺旋矩阵Ⅱ

今日题目总结：

977 有序数组的平方（双指针）
209 长度最小的子数组（滑动窗口）
59 螺旋矩阵Ⅱ （行为模拟）

leetcode 977 有序数组的平方

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

文章链接：https://programmercarl.com/0977.%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%B9%B3%E6%96%B9.html

视频链接：https://www.bilibili.com/video/BV1QB4y1D7ep/

题目描述：

在这里插入图片描述

思路：

本题最直接的方法就是暴力法，直接把每个位置的数值都进行平方，然后进行排序即可。时间复杂度为O(n+nlogn) 空间复杂度为O(1)。

仔细想想之后，数组是升序排列，但是数组中存在负数，所以我们知道平方之后新数组的最大值肯定是在左右两侧，那么我们也可以使用双指针，创建一个新的数组，每次将结果逆序填充。

方法一：暴力法

class Solution {
    public int[] sortedSquares(int[] nums) {
        //暴力法
        for(int i=0;i<nums.length;i++){
            nums[i]=nums[i]*nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }
}

方法二：双指针

class Solution {
    public int[] sortedSquares(int[] nums) {
        //双指针
        int left=0;
        int right=nums.length-1;
        int[] res = new int[nums.length];
        int count=right;
        while(left<=right){
            int temp_left=nums[left]*nums[left];
            int temp_right=nums[right]*nums[right];
            if(temp_left>=temp_right){
                res[count--]=temp_left;
                left++;
            }else{
                res[count--]=temp_right;
                right--;
            }
            return res;
        }
    }

使用双指针后时间复杂度为O(n)，比暴力法O(n+nlogn)要快一些。

leetcode 209 长度最小子数组

题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

文章链接：https://programmercarl.com/0209.%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84.html

视频链接：https://www.bilibili.com/video/BV1tZ4y1q7XE

题目描述：

在这里插入图片描述

思路一：

万物皆可暴力，所有题目给我的第一反应全是暴力解决，但事与愿违，超时了…

那我们看看暴力法的解题流程是什么吧：

我们要寻找的是一个子数组，且这个子数组的和要满足大于等于target，而且他需要是最小的。

一个for循环用来指定子数字开头位置，从0开始遍历到数组末尾，那么还需要一个循环用来不断的寻找满足条件的子数组。那么也就是两层for循环，时间复杂度为O(n*n)。

方法一：暴力法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int min_len=Integer.MAX_VALUE;
        int sum=0;
        for(int i=0;i<nums.length;i++){
            sum=0;
            for(int j=i;j<nums.length;j++){
                sum+=nums[j];
                if(sum>=target){
                    min_len= min_len <= (j-i+1) ? min_len : (j-i+1);
                    break;
                }
            }
        }
        return min_len==Integer.MAX_VALUE ? 0 : min_len;
   }
}

思路二：

滑动窗口，类似双指针，我们需要不断的调整窗口的起始位置和结束位置也就是双指针的坐指针和右指针，从而使得窗口内的结果是我们想要的结果。

暴力法我们也可以理解为是滑动窗口，第一层for循环为滑动窗口的起始位置，第二个for循环为结束位置，通过不断的调节结束位置来得到最终结果。但是暴力循环在滑动的过程中会做很多次重复操作，不推荐。

我们来看一下本题使用滑动窗口解决的动图思路。
在这里插入图片描述

大致步骤就是，当窗口里面的和小于target时，移动右指针，当窗口里面的值大于等于target时，把此时的窗口大小记录下来，也就是此时的最小长度。同时左指针也需要向右移动，在已知的窗口中寻找更小的长度。

理由如下：

我们要求的是满足条件的最小子数组，当窗口里面的和>=target时，首先不可能移动右指针，否则值会变得更大，且长度增加。那么我们移动左指针，也就是将窗口变小，让和减少，如果减小之后，仍然满足窗口和>=target的话，那么我们就需要更新最小长度了，直到窗口和<target，那么就要开始移动右指针了。

方法二：滑动窗口

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int min_len=Integer.MAX_VALUE;
        int sum=0;
        int left=0;
        int right=0;
        while(right<nums.lenght){
            sum+=nums[right];
            while(sum>=target){
                min_len= min_len <= (right-left+1) ? min_len : (right-left+1);
                sum-=nums[left];
                left++;
            }
            right++;
        }
        return min_len==Integer.MAX_VALUE ? 0 : min_len;
   }
}

在这里开始有个疑惑，滑动窗口不是两个while循环吗？时间复杂度不是跟暴力法一样吗都是O(n*n)?

其实不然，对于时间复杂度我们不能只看有几个for循环或while循环，时间复杂度应该看每个元素操作的次数，

对于滑动窗口，每个元素都会被操作两次，也就是进窗口和出窗口，那么时间复杂度应该是O(2n)，也就是O(n)了。

leetcode 59 螺旋矩阵Ⅱ

题目链接：https://leetcode.cn/problems/spiral-matrix-ii/

文章链接：https://programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html

视频链接：https://www.bilibili.com/video/BV1SL4y1N7mV

思路：

其实本题考查的是行为模拟，就是如何将整个过程给模拟出来，十分考察我们的边界处理能力。

在这里我提供两种解法。

方法一：个人习惯

在这里插入图片描述

我们可以模拟每条边的填充规则。这里我也不知道该怎么描述才能描述清楚，直接看代码能够更清晰的了解。

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res =new int[n][n];
        int top =0;//顶部
        int right=n-1;//右边
        int button=n-1;//底部
        int left=0;//左边
        int count=1;
        while(count<=n*n){
            //模拟顶部
            for(int i=left;i<=right;i++){
                res[top][i]=count++;
            }
            top++;
            //模拟右边
            for(int i=top;i<=button;i++){
                res[i][right]=count++;
            }
            right--;
            //模拟底部
            for(int i=right;i>=left;i--){
                res[button][i]=count++;
            }
            button--;
            //模拟左边
            for(int i=button;i>=top;i--){
                res[i][left]=count++;
            }
            left++;
        }
        return res;
    }
}

方法二：卡哥思路

每次填充的时候都留出最后的转角点。（个人习惯还是方法一）
在这里插入图片描述

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;  // 控制循环次数
        int[][] res = new int[n][n];
        int start = 0;  // 每次循环的开始点(start, start)
        int count = 1;  // 定义填充数字
        int i, j;

        while (loop++ < n / 2) { // 判断边界后，loop从1开始
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {
                res[start][j] = count++;
            }

            // 模拟右侧从上到下
            for (i = start; i < n - loop; i++) {
                res[i][j] = count++;
            }

            // 模拟下侧从右到左
            for (; j >= loop; j--) {
                res[i][j] = count++;
            }

            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                res[i][j] = count++;
            }
            start++;
        }

        if (n % 2 == 1) {
            res[start][start] = count;
        }

        return res;
    }
}