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

977.有序数组的平方

链接: 有序数组的平方

思路

最直接的做法，即暴力解法，就是对数组中的每一个元素进行平方，也是能通过的。但更高效的做法是双指针，这里指左右指针。

解题方法

• 暴力解法直接看下文代码，就是定义一个新的数组来存储nums数组的每一个元素的平方。
• 双指针之左右指针：
  平方的特点是会把负数变成正数，那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。所以一个负数和一个正数平方后的大小要根据绝对值来比较。
  我们直接将双指针分别初始化在 nums 的开头和结尾，相当于合并两个从大到小排序的数组。

注：
还有一种双指针的方法
我们可以把元素 0 作为分界线，0 左侧的负数是一个有序数组 nums1，0 右侧的正数是另一个有序数组nums2.
所以，我们可以去寻找正负数的分界点，然后向左右扩展，执行合并有序数组的逻辑。
代码就不实现了，有兴趣的读者可以自己实现一下。

复杂度

Code

1. 暴力解法

• 时间复杂度：O(nlogn),其中n是数组的长度
• 空间复杂度：O(logn),除了存储答案的数组以外，我们需要 O(log⁡n) 的栈空间进行排序。

2. 双指针

• 时间复杂度：O(n)
• 空间复杂度：O(1)

暴力解法

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> res(nums.size());
        for (int i = 0; i < nums.size(); i++) {
            res[i] = nums[i] * nums[i];
        }
        sort(res.begin(), res.end());
        return res;
    }
};

双指针

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        //两个指针分别初始化在正负子数组绝对值最大的元素索引
        int i = 0, j = n - 1;
        //这里得到的有序结果是降序的
        int pos = n - 1;
        vector<int> res(n);
        //使用双指针合并有序数组
        while (i <= j) {
            if (abs(nums[i]) > abs(nums[j])) {
                res[pos] = nums[i] * nums[i];
                i++;
            } else {
                res[pos] = nums[j] * nums[j];
                j--;
            }
            pos--;
        }
        return res;
    }
};

209.长度最小的子数组

链接: 长度最小的子数组

滑动窗口理论基础

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

在暴力解法中(下文)，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环 完成了一个不断搜索区间的过程。

那么滑动窗口如何用一个for循环来完成这个操作呢。

首先要思考 如果用一个for循环，那么应该表示 滑动窗口的起始位置，还是终止位置。

如果只用一个for循环来表示 滑动窗口的起始位置，那么如何遍历剩下的终止位置？

此时难免再次陷入 暴力解法的怪圈。

所以 只用一个for循环，那么这个循环的索引，一定是表示 滑动窗口的终止位置。

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

思路

暴力解法当然是 两个for循环，然后不断的寻找符合条件的子数组，时间复杂度很明显是O(n^2)。
更到校的做法是是使用滑动窗口。

解题方法

• 暴力解法直接看下文代码.
• 本题使用滑动窗口：
  在本题中实现滑动窗口，主要确定如下三点：

窗口内是什么？
如何移动窗口的起始位置？
如何移动窗口的结束位置？
窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

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

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

可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

复杂度

1. 暴力解法

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

2. 滑动窗口

• 时间复杂度：O(n)
• 空间复杂度：O(1)

Code

暴力解法

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }

        int res = INT_MAX;
        for (int i = 0; i < n; i++) {
            int sum = 0;
            for (int j = i; j < n; j++) {
                sum += nums[j];
                if (sum >= target) {
                    res = min(res, j - i + 1);
                    break;
                }
            }
        }
        return res == INT_MAX ? 0 : res;
    }
};

滑动窗口

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int res = INT_MAX;
        int sum = 0; //滑动窗口的数值之和
        int i = 0;   //滑动擦混港口的起始位置
        int len = 0; //滑动窗口的起始长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新
            // i（起始位置），并不断比较子数组是否符合条件
            while (sum >= target) {
                len = j - i + 1; //取子数组的长度
                res = res < len ? res : len;
                sum -= nums[i++]; //不断变更i（子数组的起始位置）
            }
        }

        // res没有被赋值的话，就返回0，说明没有符合条件的子数组
        return res == INT_MAX ? 0 : res;
    }
};

注：
不要以为for里放一个while就以为是O(n^2)， 主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

59.螺旋矩阵II

链接: 螺旋矩阵II

思路

本体不涉及什么算法，就是让你模拟，但比较考验代码功底。

解题方法

按照右、下、左、上的顺序遍历数组，并使用四个变量圈定未遍历元素的边界，随着螺旋遍历，相应的边界会收缩，直到螺旋遍历完整个数组。
但你要坚持一种区间的写法，不能前边左闭右开，后边写着写着就变成了左闭右闭的写法了。

复杂度

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

Code

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> matrix(n, vector<int>(n, 0));
        int upper_bound = 0, lower_bound = n - 1;
        int left_bound = 0, right_bound = n - 1;
        // 需要填入矩阵的数字
        int num = 1;

        while (num <= n * n) {
            if (upper_bound <= lower_bound) {
                // 在顶部从左向右遍历
                for (int j = left_bound; j <= right_bound; j++) {
                    matrix[upper_bound][j] = num++;
                }
                // 上边界下移
                upper_bound++;
            }

            if (left_bound <= right_bound) {
                // 在右侧从上向下遍历
                for (int i = upper_bound; i <= lower_bound; i++) {
                    matrix[i][right_bound] = num++;
                }
                // 右边界左移
                right_bound--;
            }

            if (upper_bound <= lower_bound) {
                // 在底部从右向左遍历
                for (int j = right_bound; j >= left_bound; j--) {
                    matrix[lower_bound][j] = num++;
                }
                // 下边界上移
                lower_bound--;
            }

            if (left_bound <= right_bound) {
                // 在左侧从下向上遍历
                for (int i = lower_bound; i >= upper_bound; i--) {
                    matrix[i][left_bound] = num++;
                }
                // 左边界右移
                left_bound++;
            }
        }
        return matrix;
    }
};

总结

• 对于本次的三道算法题，第一道很简单，思路也清晰；对于第二题，熟悉了滑动窗口的理论，但还是很不熟练，需要多练习；对于第三题，代码量多，不难，但是要理解其中的思路和保持统一的区间，以免到后面写乱。
• 参考文档：代码随想录
  链接: 有序数组的平方
  链接: 长度最小的子数组
  链接: 螺旋矩阵II