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

Leetcode 977.有序数组的平方

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/
视频讲解： https://www.bilibili.com/video/BV1QB4y1D7ep
文章讲解：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

没看题解前：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int leftIndex = 0, rightIndex = nums.size() - 1;
        vector<int> new_nums(nums);
        int flag = new_nums.size() - 1;
        while (leftIndex <= rightIndex) {
            while (leftIndex <= rightIndex && (nums[leftIndex] * nums[leftIndex]) >= (nums[rightIndex] * nums[rightIndex])) {
                new_nums[flag--] = nums[leftIndex] * nums[leftIndex];
                leftIndex++;
            }
            while (leftIndex <= rightIndex && (nums[leftIndex] * nums[leftIndex]) < (nums[rightIndex] * nums[rightIndex])) {
                new_nums[flag--] = nums[rightIndex] * nums[rightIndex];
                rightIndex--;
            }
        }
        return new_nums;
    }
};

看题解优化后：
将内层的while循环的部分移到外层进行，这样可以避免在内层while循环中数组访问溢出，将leftIndex <= rightIndex一并放置在外层进行判断。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int leftIndex = 0, rightIndex = nums.size() - 1;
        vector<int> new_nums(nums);
        int flag = new_nums.size() - 1;
        while (leftIndex <= rightIndex) {
            if ( (nums[leftIndex] * nums[leftIndex]) >= (nums[rightIndex] * nums[rightIndex])) {
                new_nums[flag--] = nums[leftIndex] * nums[leftIndex];
                leftIndex++;
            }
            else {
                new_nums[flag--] = nums[rightIndex] * nums[rightIndex];
                rightIndex--;
            }
        }
        return new_nums;
    }
};

感觉思路是一致的，但是代码有点臃肿，其实表达意思是一样的，时间复杂度应该是相同的，都是O(n)。

209.长度最小的子数组

题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/
视频讲解：https://www.bilibili.com/video/BV1tZ4y1q7XE
文章讲解：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

思路：双指针，滑动窗口，关键在于在移动终止位置的时候，初始位置是不可逆的，初始位置只可能往后移动，而不用每次都从第零个元素开始。
所有双指针法，都是充分利用题目的一个隐藏的特征，来对暴力算法的一种简化。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0, sum = 0, result = INT32_MAX, subLen = 0;
        for (int j = 0; j <= nums.size() - 1; j++) {
            sum += nums[j];
            while (sum >= target) {
                subLen = j - i + 1;
                result = result > subLen ? subLen : result;
                sum -= nums[i];
                i++;
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

螺旋矩阵Ⅱ

题目链接：https://leetcode.cn/problems/spiral-matrix-ii/
视频讲解：https://www.bilibili.com/video/BV1SL4y1N7mV/
文章讲解：https://programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html

思路：确保变量一致性，使每一个边都是左开右闭。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int> (n, 0));
        int startx = 0, starty = 0, count = 1, offset = 1, loop = n / 2, mid = n / 2;
        int i, j;
        while (loop--) {
            j = starty;
            i = startx;
            for (; j < n - offset; j++) {
                result[startx][j] = count++;
            }
            for (; i < n - offset; i++) {
                result[i][j] = count++;
            }
            for (; j > starty; j--) {
                result[i][j] = count++;
            }
            for (; i > startx; i--) {
                result[i][j] = count++;
            }
            startx++;
            starty++;
            offset++;
        }
        if (n % 2 ==  1) result[mid][mid] = count;
        return result;
    }
};