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

LetCode977 .有序数组平方

视频讲解：https://www.bilibili.com/video/BV1QB4y1D7ep

题目描述：

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

个人思路：
个人第一反应就是先对数组平方，如何使用内置函数sort对数据进行排序，这样就能做出来。代码如下：

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

这个时间复杂度是 O(n + nlogn)， 可以说是O(nlogn)的时间复杂度，但为了和下面双指针法算法时间复杂度有鲜明对比。

但是这道题也可以考虑使用双指针的思路去做，

数组其实是有序的， 只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法了，i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int >result(nums.size(),0);
        int left=0;
        int right=nums.size()-1;
        int index=nums.size()-1;
        while(left<=right){
            if(nums[left]*nums[left]<nums[right]*nums[right]){
                result[index]=nums[right]*nums[right];
                right--;
                index--;
            }else{
                result[index]=nums[left]*nums[left];
                left++;
                index--;
            }
        }
        return result;
    }
};

时间复杂度为O(n )。

LeetCode 209 长度最小的子数组

视频讲解：https://www.bilibili.com/video/BV1tZ4y1q7XE

题目描述：

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

个人思路：知道要用滑动窗口，但是由于不太熟练，所以没有做出来。

简单介绍一下滑动窗口：

接下来就开始介绍数组操作中另一个重要的方法：滑动窗口。

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

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

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

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

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

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

所以 只用一个for循环，那么这个循环的索引，一定是表示 滑动窗口的终止位置。用一个for循环来实现两个for循环的功能。其具体代码实现如下：

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

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

Leetcode59:螺旋矩阵

视频讲解：一入循环深似海 | LeetCode：59.螺旋矩阵II_哔哩哔哩_bilibili

题目描述：给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列

的 n x n 正方形矩阵 matrix 。

emmm本题没有任何思路，所以看的题解。

解题方法：

个人感觉这道题自己需要多在下面模拟一下过程，多理解一遍。

而求解本题依然是要坚持循环不变量原则。

模拟顺时针画矩阵的过程:

• 填充上行从左到右
• 填充右列从上到下
• 填充下行从右到左
• 填充左列从下到上

由外向内一圈一圈这么画下去。

首先对于一个矩阵定义一个上下左右四个变量，如何在依此进行遍历，这里需要注意左右的开闭区间，一般常见的方法有两种，左闭右开，或者左闭右闭。这个就要看个人怎么理解。

左闭右闭：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int left=0;
        int right=n-1;
        int top=0;
        int bottom=n-1;
        int num=1;
        while(left<=right&&top<=bottom){
            for(int i=left;i<=right;i++){
                res[top][i]=num++;
            }//从左往右
            top++;
            //从上往下
            for(int i=top;i<=bottom;i++){
                res[i][right]=num++;
            }
            right--;
            //从右到左
            if(top<=bottom){
                for(int i=right;i>=left;i--){
                    res[bottom][i]=num++;
                }
                bottom--;
            }
            //最后从下到上
            if(left<=right){
                for(int i=bottom;i>=top;i--){
                    res[i][left]=num++;
                }
                left++;
            }
        }
        return res;
    }
};

注意这里是左闭右闭所以每次遍历完成之后，要对边界进行额外处理。

左闭右开：对于左闭右开的区间，需要定义一个额外的偏移量，以及当输入n为奇数的一个处理方法，但大致思路是一样的。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int loop=n/2;
        int mid=n/2;
        int i,j;
        int count=1;
        int offset=1;
        int startx=0;
        int starty=0;
        while(loop--){
            i=startx;
            j=starty;
            for(j;j<n-offset;j++){
                res[i][j]=count++;
            }
            for(i;i<n-offset;i++){
                res[i][j]=count++;
            }
            for(j;j>starty;j--){
                res[i][j]=count++;
            }
            for(i;i>startx;i--){
                res[i][j]=count++;
            }
            startx++;
            starty++;
            offset+=1;
        }
        if(n%2){
            res[mid][mid]=count;
        }
        return res;
    }
};

• 时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
• 空间复杂度 O(1）

在理解完这道题之后又去做了一道类似的题目

LeetCode 54 螺旋矩阵

思路与上面的也是一样的，采用左闭右闭的方法。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector <int> ans;
        // if(matrix.empty()) return ans; //若数组为空，直接返回答案
        int top=0;
        int left=0;
        int right=matrix[0].size()-1;
        int bottom=matrix.size()-1;
        while(left<=right&&top<=bottom){
            for(int i=left;i<=right;i++){
                ans.push_back(matrix[top][i]);
            }
            top++;
            for(int i=top;i<=bottom;i++){
                ans.push_back(matrix[i][right]);
            }
            right--;
            //从右到左
            if(top<=bottom){
                for(int i=right;i>=left;i--){
                   ans.push_back(matrix[bottom][i]);
                }
                bottom--;
            }
            //最后从下到上
            if(left<=right){
                for(int i=bottom;i>=top;i--){
                      ans.push_back(matrix[i][left]);
                }
                left++;
            }
        }
        return ans;
    }
};

打卡第二天，今天花的时间比较久，还有更多需要改进的地方，继续加油！