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

977.有序数组的平方

题目链接

首先审题：
数组为非递减排序的整数数组，平方后返回的新数组也为非递减排序。

暴力解法

最先想到的解法是：遍历取平方之后，再排序。
时间复杂度为O(n+nlogn)，取决于库函数sort，即快速排序的时间复杂度。
sort函数的原理和使用可见链接

题解代码如下：

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

双指针法

数组是有序的，所以平方后的最大数只能在数组的左右两侧。
故考虑两个指针，分别指向数组的第一个和最后一个数，然后向中间合拢，得到一个由大到小的新数组，那么下表由大到小更新，便能获得一个升序的新数组。
时间复杂度： O(n)

题解代码如下：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        for (int i = 0, j = nums.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (nums[i] * nums[i] < nums[j] * nums[j])  {
                result[k--] = nums[j] * nums[j];
                j--;
            }
            else {
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};

错误总结： 数组下标k为nums.size() - 1，报错为数组下标越界。i<=j后需要；，注意语法。

209.长度最小的子数组

题目链接

暴力解法

两个for循环，遍历以每一个数为开头的最小连续子数列。
代码如下：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX; // 最终的结果
        int sum = 0; // 子序列的数值之和
        int subLength = 0; // 子序列的长度
        for (int i = 0; i < nums.size(); i++) { // 设置子序列起点为i
            sum = 0;
            for (int j = i; j < nums.size(); j++) { // 设置子序列终止位置为j
                sum += nums[j];
                if (sum >= s) { // 一旦发现子序列和超过了s，更新result
                    subLength = j - i + 1; // 取子序列的长度
                    result = result < subLength ? result : subLength;
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

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

滑动窗口

思路：只用一个for循环，该for循环表示子列终止的位置。
在for循环中，用一个while来动态调整子列的长度，当子列和大于target时便剔出第一个元素，直到子列和小于target。
实际上根据题目的信息来对两层for进行剪枝，本题要求的是最小连续子列，故可以考虑滑动窗口法。
代码如下：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

时间复杂度：O(n) （每个元素在进出时各操作一次，故为2n）
空间复杂度：O(1）

59.螺旋矩阵II

坚持左开右闭的思路，边界处理上就不会混乱
时间复杂度：O(n^2)

代码如下：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n, 0)); 
        int startx = 0, starty = 0;
        int loop = n/2;
        int mid = n/2;
        int count = 1;
        int offset = 1;
        int i,j;
        while (loop--) {

            i = startx;
            j = starty;
            
            for (; j < n - offset; j++) {
                result[i][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 += 1;
        }
        if (n % 2 == 1) {
                result[mid][mid] = n*n;
            }
        return result;
    }
};

P.S. 在看了视频和思路之后，写出的代码与随想录给出的有一些细节上的不同。