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

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

详细布置

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

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

解答
这是我看到题后马上想到的做法，使用快慢指针将数组元素全部平方处理，然后使用冒泡排序。

class Solution {
    public int[] sortedSquares(int[] nums) {
    	//双指针
        int slowIndex = 0;
        for(int fastIndex = 0; fastIndex < nums.length; fastIndex++){
            nums[slowIndex++] = nums[fastIndex] * nums[fastIndex];
        }
        //冒泡排序
        for(int i = 0; i < nums.length; i++){
            for(int j = 0; j < nums.length - i - 1; j++){
                if(nums[j + 1] < nums[j]){
                    int temp = nums[j + 1];
                    nums[j + 1] = nums[j];
                    nums[j] = temp;
                }
            }
        }
        return nums;
    }
}

但是这种做法时间复杂度为O(n^2)，需要改进方法。

双指针法

class Solution {
    public int[] sortedSquares(int[] nums) {
        //定义双指针
        int leftIndex = 0;
        int rightIndex = nums.length - 1;
        //定义存放平方数的数组，长度和nums的长度一致
        int length = nums.length;
        int[] squares = new int[length];
        //当左指针小于等于右指针的时候，要取等于是因为当左右指针相等的时候会丢失一个数值
        while(leftIndex <= rightIndex){
            //要得到非递减顺序的数组，也就是右侧的数最大，将最大的平方数赋值到最右侧
            if(nums[leftIndex] * nums[leftIndex] < nums[rightIndex] * nums[rightIndex]){
                squares[length - 1] = nums[rightIndex] * nums[rightIndex];
                //平方数组向左移动一位
                length--;
                //右指针向左移动
                rightIndex--;
            }
            else{
                squares[length - 1] = nums[leftIndex] * nums[leftIndex];
                //平方数组向左移动一位
                length--;
                //左指针向右移动
                leftIndex++;
            }
        }
        return squares;
    }
}

这种写法的时间复杂度为O(n)，执行时间上缩短了不少。

小结
使用双指针分别位于数组两端，对他们的平方大小进行比较，将大的存入新数组。

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

题目
给定一个含有 n 个正整数的数组和一个正整数 target。

找出该数组中满足其总和大于等于 target 的长度最小的连续子数组[numsl, numsl+1,…, numsr-1, numsr]，并返回其长度。如果不存在符合条件的子数组，返回0。

解答
暴力解法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //因为要找出min的最小值，为了第一组大小比较需要将min赋值位最大值
        int min = Integer.MAX_VALUE;
        for(int i = 0 ; i < nums.length ; i++){
            int sum = nums[i];
            //特殊情况判断
            if(sum >= target){
                return 1;
            }
            for(int j = i + 1 ; j < nums.length ; j++){
                sum += nums[j];
                //两层循环找出最小值
                if(sum >= target){
                    min = Math.min(min,j + 1 - i);
                    //跳出第二层循环
                    break;
                }
            }
        }
        //三元运算符，如果答案为Integer.MAX_VALUE,则答案为0，否则为min
        return min == Integer.MAX_VALUE ? 0 : min;
    }
}

时间复杂度为O(n^2)，需要进一步改进算法。

滑动窗口
所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。
在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环 完成了一个不断搜索区间的过程。

那么滑动窗口如何用一个for循环来完成这个操作呢？
首先要思考如果用一个for循环，那么应该表示滑动窗口的起始位置，还是终止位置。
如果只用一个for循环来表示滑动窗口的起始位置，那么如何遍历剩下的终止位置？
此时难免再次陷入暴力解法的怪圈。
所以只用一个for循环，那么这个循环的索引，一定是表示滑动窗口的终止位置。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int leftIndex = 0;
        //因为要找出min的最小值，为了第一组大小比较需要将min赋值位最大值
        int min = Integer.MAX_VALUE;
        int sum = 0;
        for(int rightIndex = 0 ; rightIndex < nums.length ; rightIndex++){
            sum += nums[rightIndex];
            //这里要用while进行判断，因为如果只用if的话左指针只会移动一次，如果sum任然大于等于target不会继续判断
            while(sum >= target){
                //更新最短长度
                min = Math.min(min,rightIndex - leftIndex + 1);
                //左指针右移，寻找新的最短长度
                sum = sum - nums[leftIndex];
                leftIndex++;
            }
        }
        return min == Integer.MAX_VALUE ? 0 : min;
    }
}

小结
滑动窗口使用的关键就是for循环索引的是滑动窗口的终点位置，每次循环起点位置向后移动。

59.螺旋矩阵II

题目建议：本题关键还是在转圈的逻辑，在二分搜索中提到的区间定义，在这里又用上了。

题目链接：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/

题目
给你一个正整数 n ，生成一个包含1到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix。

解答

class Solution {
    public int[][] generateMatrix(int n) {
        //确定循环不变量：包括每一条边的第一个值但不包括边的最后一个值
        int start = 0;
        int[][] res = new int[n][n];
        int i,j;
        //每次填充的数字，从1至n^2
        int num = 1;
        //定义所经历的圈数，初始为0
        int round = 0;
        //如果n为偶数，那么矩阵的圈数为n/2,如果为基数那么圈数也为n/2，并且中间元素要单独赋值
         while(round < n / 2){
         	//第一圈开始，round++
            round++;
            //上边,i为start，j自增
            for(j = start ; j < n - round ; j++){
                res[start][j] = num;
                num++; 
            }
            //右边,j为start，i自增
            for(i = start ; i < n - round ; i++){
                res[i][j] = num;
                num++; 
            }
            //下边,j自减
            for(; j >= round ; j--){
                res[i][j] = num;
                num++; 
            }
            //左边,i自减
            for(; i >= round ; i--){
                res[i][j] = num;
                num++; 
            }
            //执行完一圈后，start初始值需要++，作为下一圈的初始值
            start++;
        }
        //如果n为基数，那么最中间需要单独赋值
        if(n % 2 == 1){
            res[start][start] = n * n;
        }
        return res;
    }
}

小结
螺旋数组的解题关键在于确定循环不变量，即每条边都应该采取同样的处理方法。
start表示起始位置，round表示循环圈数，对于n为基数的矩形最中间的数需要单独赋值。

总结

今天的题目好难，花了不少时间，继续加油！