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

RuojiFW

已于 2023-02-11 11:48:23 修改

阅读量240

点赞数

文章标签：算法矩阵 leetcode

于 2023-02-02 11:15:45 首次发布

本文链接：https://blog.csdn.net/KINGjunT/article/details/128844082

版权

977.有序数组的平方

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

思路1：到手第一感觉，先遍历数组，平方之后再排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
       for (int i = 0; i < nums.size(); i++) {
           nums[i] = nums[i]*nums[i];
       }
       sort(nums.begin(), nums.end());
       return nums;
    }
};
//时间复杂度O(n + logn)
//空间复杂度O(1)

思路2：双指针法，考虑到原始数组并不是全是正数，负数的平方有可能会更大。那么可以从左右两边平方后，比完之后大的放在一个新的数组最后面，左边先后移，右边向前移。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int left = 0; //左指针
        int right = nums.size() - 1;  // 右指针
        int k = nums.size() - 1;  //新数组的最大长度
        vector<int> ans(nums.size());  // 开辟的新数组
        // 当左指针小于右指针时，两个指针指向同一个点时，随便返回一个就行
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
            //左指针大放左边，同时进行指针移动
                ans[k] = nums[left] * nums[left];
                k--;
                left++;
            }
            else {
            //包含了右指针大和两个指针相等的情况
                ans[k] = nums[right] * nums[right];
                k--;
                right--;
            }
        }
        return ans;
    }
};
//时间复杂度O(n)
//空间复杂度O(n)  开辟了一个新的数组，空间换时间

总结

双指针法是数组中常用的方法，需要掌握怎么移动，定的位置在哪合适，所以需要加大练习。

209.长度最小的子数组

题目链接
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

思路1暴力解法：首先拿一层for循环控制起始位置，另外一层控制终止位置，当最短系列加起来的值大于等于target以后，中断循环，然后继续下一轮。

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

// 超出了时间限制
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int res = INT32_MAX; // 最终结果
        int subLen = 0; //子序列长度
        for (int i = 0; i < nums.size(); i++) {
            int sum = 0;
            for (int j = i; j < nums.size(); j++) {
                sum += nums[j];
                if (sum >= target) {
                    subLen = j - i + 1; //获取子序列长度
                    // 判断赋值
                    res = res < subLen ? res : subLen;
                    break;
                }
            }     
        }
        return res == INT32_MAX ? 0 : res;
    }
};

思路2 滑动窗口： 所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。只用一个for循环，那么指向的一定是终止位置。

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

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int res = INT32_MAX; // 设置返回值
        int subLen = 0; // 设定子序列长度
        int i = 0; // 初始化起始位置
        int sum = 0; // 初始化子序列累加和
        for (int j = 0; j < nums.size(); j++) { // 用 j 控制终止位置
            sum += nums[j]; // 遍历计算累加和
            // 直到累加和大于等于目标值
            while (sum >= target) {
                subLen = j - i + 1; // 获取序列长度
                res = res < subLen ? res : subLen; // 更新返回值
                sum -= nums[i]; // 将滑动窗口的初始位置值减去，再得到子序列和
                i++; // 初始位置移动
            }
        }
        return res == INT32_MAX ? 0 : res;
    }
};

总结：

先从暴力解法理解如何遍历得到最短的子序列长度，然后进而得到滑动窗口的方法。如何确定滑动窗口的起始位置，是精华所在

while (sum >= target) {
   	subLen = j - i + 1; // 获取序列长度
   	res = res < subLen ? res : subLen; // 更新返回值
    sum -= nums[i]; // 将滑动窗口的初始位置值减去，再得到子序列和
    i++; // 初始位置移动，不断变更起始位置
}

59.螺旋矩阵II

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

思路： 主要是循环不变量的思想，确定好边界条件时本题的关键。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> ans(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int x, y = 0; // 定义每一圈初始位置（x, y）
        int loop = n / 2; // 定义循环圈数
        int mid = n / 2; // 当n为奇数时，最中间的数
        int offset = 1; // 每次遍历时，要控制的离开最后的数
        int i,j;
        int count = 1; // 需要填入矩阵的值

        while (loop--) {
            i = x; // 定义初始位置
            j = y;

            for (j = y; j < n- offset; j++) {
                ans[x][j] = count++;
            }
            // 从上到下
            for (i = x; i < n - offset; i++) {
                ans[i][j] = count++;
            }
            //从右往左
            for (; j > y; j--) {
                ans[i][j] = count++;
            }
            // 从下往上
            for (; i > x; i--) {
                ans[i][j] = count++;
            }
            x++; y++;
            offset += 1;
        }
        if (n % 2) {
            ans[mid][mid] = count;
        }
        return ans;
    }
};