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

希希雾里

已于 2023-07-24 13:42:59 修改

阅读量139

点赞数 1

分类专栏：代码随想录感想文章标签：算法 leetcode 数据结构 c++

于 2022-12-11 16:36:43 首次发布

本文链接：https://blog.csdn.net/weixin_42373086/article/details/128259033

版权

代码随想录感想专栏收录该内容

23 篇文章 0 订阅

订阅专栏

一、有序数组的平方

题目简述：

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

思路和实践：

初步想法：先遍历数组将所有都平方，之后再排序，排序上采用库函数sort方法，sort函数的内核是冒泡法和插入法。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //暴力法
        vector<int> aimSeries = nums;   //aimSeries是容器变量，里面存放int数据
        int size = aimSeries.size();
        //先平方
        for(int i = 0; i < size; i++){
            aimSeries[i] = pow(aimSeries[i],2);
        }
        //后排序,sort排序是简单的，他的原理是什么？
        sort(aimSeries.begin(), aimSeries.end()); 
        return aimSeries;
    }
};

进一步的思考：发现数组可以大致分为负数区段和整数区段，对数组进行平方进行排序其实就是绝对值的排序，将所有数取正后发现，数组会分为一个递减区间+递增区间。

这里可以发现数组的最大值一定会出现在数组的两端，那么双指针代表的两个角度，就分别代表数组的两端。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //双指针法
        vector<int> result = nums;
        int k = result.size() - 1;
        for(int i = 0, j = nums.size() - 1; i <= j;){
            if((nums[i] * nums[i]) < (nums[j] * nums[j])){
                result[k--] = nums[j] * nums[j];
                j--;
            }
            else if((nums[i] * nums[i]) >= (nums[j] * nums[j])){
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};

二、长度最小的子数组

题目简述：

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

思路和实践：

（1）暴力法

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int minSize = nums.size();      //用于记录最小长度
        int result = 0;                 //子序列数值之和
        int subLength = 0;              //最小子序列的长度，输出结果，如果默认，
        //暴力法，就是一次遍历，之后一一加和判断,如果
        for(int i = 0; i < nums.size();i++){
            result = 0;
            for(int j = 0; j + i < nums.size(); j++){
                result += nums[i + j];
                if(result >= target){
                    if(j + 1 <= minSize){
                        minSize = j + 1;
                        subLength = minSize;
                        result = 0;
                        break;                  //找到最小序列，就跳出循环
                    }
                }
            }
        }
        return subLength;
    }
};

但是采用这个这种方法的时间复杂度是o(n^2)，运行这个代码，以下这个例子出现超出时间限制这个错误。

（2）滑动窗口法（双指针）

那如何降低算法的时间复杂度，暴力法里有哪些步骤是冗余的

我们可以发现使用暴力法是去找整个数组每个元素的最短序列，其实只需要去寻找比之前满足条件子序列更短的子序列。

具体思路如下图所示：

//滑动窗口的精髓地方就在于更新窗口起始位置
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int subLength = 0; //子序列长度
        int subSum = 0;    //滑动窗口之和
        int minResult = INT32_MAX;     //输出的最小子序列长度
        int slowIndex = 0;     
        for(int fastIndex = 0;fastIndex < nums.size();fastIndex++){
            subSum += nums[fastIndex];
            while(subSum >= target){
                subLength = fastIndex -slowIndex + 1;
                minResult = minResult < subLength ? minResult : subLength;
                subSum -= nums[slowIndex++];
            }
        }
        return minResult == INT32_MAX ? 0 : minResult;
    }
};

收获：在定义变量以及变量怎么使用上，需要去训练仔细和思考。

三、螺旋矩阵

题目简述：

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

思路和实践：

这里有四个状态：对应上图的1、2、3以及4，之后就是考虑旋转的圈数。主要考虑的问题有如下两个：

边界拐角值：可以看出是有重合的地方，就是图上的拐角，所以在这里就选择了左闭右开的方式循环，这样子就不会重复了。
中间值：这个方阵是奇数阵还是偶数阵，如果是奇数阵的话，则需要单独处理中间值。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); 
        int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
        int loop = n / 2; // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2; // 矩阵中间的位置
        int count = 1; // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int i,j;
        while (loop --) {
            i = startx;
            j = starty;

            // 模拟填充上行从左到右(左闭右开)
            for (j = starty; j < n - offset; j++) {
                res[startx][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (i = startx; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {
                res[i][j] = count++;
            }

            // 第二圈开始的时候
            startx++;
            starty++;

            // offset 控制每一圈里每一条边遍历的长度
            offset += 1;
        }

        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};