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

977.有序数组的平方

题目链接：977.有序数组的平方
文章讲解：文章链接
视频讲解：视频链接

代码思路：通过前期的分析可知，数组元素的平方的最大值一定是在数组的左右两边，因此可以通过对撞指针来判断数组两边的数的大小，将大的值从后往前存放在一个新的数组里面，直到左右两个指针将整个数组检查完结束，返回存放我们排好序的新数组即可。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int numLen = nums.size();
        int k = numLen - 1;
        vector<int> res(numLen, 0);
        //注意这里需要left <= right
        for (int left = 0, right = numLen - 1; left <= right;) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                res[k] = nums[left] * nums[left];
                left++;

            } else {
                res[k] = nums[right] * nums[right];
                right--;
            }
            k--;
        }
        return res;
    }
};

209.长度最小的子数组

题目链接：209.长度最小的子数组
文章讲解：文章链接
视频讲解：视频链接

代码思路：滑动窗口解题，定义窗口的起始位置和终止位置的指针，终止位置的指针遍历整个数组，起始位置的指针根据窗口的条件进行移动，动态更新最小解的数组长度。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int start = 0;
        int sumNum = 0;
        int window = 0;
        int result = INT32_MAX;//注意这个的目的是为了判断没有元素符合条件返回0
        for (int end = 0; end < nums.size(); end++) {
            sumNum += nums[end];
            while (sumNum >= target) {
                window = end - start + 1;
                result = result < window ? result : window;
                sumNum -= nums[start];
                start++;
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

59.螺旋矩阵II

题目链接：59.螺旋矩阵II
文章讲解：文章链接
视频讲解：视频链接

解题思路：按照题目描述依次填写二维数组的元素，分析找到循环不变的条件。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0));//创建二位数组并填充0
        int startx = 0;
        int starty = 0;
        int offset = 1;
        int count = 1;//填充数
        for (int a = 0; a <= (n / 2); a++) { 
            int i = startx;
            int j = starty;
            for (; j < n - offset; j++) {
                res[i][j] = count++;
            }
            for (; i < n - offset; i++) {
                res[i][j] = count++;
            }
            for (; j > offset - 1; j--) {
                res[i][j] = count++;
            }
            for (; i > offset - 1; i--) {
                res[i][j] = count++;
            }
            offset++;
            startx++;
            starty++;
        }

        if (n % 2) {
            res[n / 2][n / 2] = count;
        }
        return res;

    }
};