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

数组类题目方法参考：暴力，二分法，双指针法，滑动窗口

LeetCode977.有序数组的平方

题目链接：977.有序数组的平方

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

思考：递增数组，可能包含重复的值，还有负数。返回有序的数字平方组成的新数组

思路一：将负数变成正数，对新数组进行排序，再将每个数变成平方数

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

思路二：双指针法：非递减的数组（包含负数），如果将其平方，最大值分布在两边，不会分布在中间。定义两个指针slow和fast，slow指向最左端，fast指向最右端。再定义一个新数组result，容量一样，定义k指向最后一个位置，比较slow和fast所在的最大值，填入k，最后新数组就是所求的数组

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size()-1;
        vector<int> result(nums.size(), 0);
        
        int slow=0, fast=nums.size()-1;
        while(slow <= fast){
            if(nums[slow]*nums[slow] < nums[fast]*nums[fast]){
                result[k--] = nums[fast]*nums[fast];
                fast--; //写代码的时候忘记对fast和slow进行处理了，很容易犯这种粗心的问题
            }else{
                result[k--] = nums[slow]*nums[slow];
                slow++;
            }
        }
        return result;

    }
};

LeetCode209.长度最小的子数组

题目链接：长度最小的子数组

题目描述：给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度**。**如果不存在符合条件的子数组，返回 0 。

思路一：滑动窗口，滑动窗口可以理解为双指针法的一种。

窗口：满足和大于等于s的长度最小的连续子数组

窗口的起始位置如何移动：当窗口值大于s，窗口向前移动（缩小）

窗口的终止位置如何移动：一直遍历，直到窗口值大于s

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result =INT32_MAX;
        int sum = 0;
        int length = 0; //窗口的长度
        int i=0; //窗口的起始位置
        for(int j=0; j<nums.size(); j++){
            sum += nums[j];
            while(sum >= target){ //尝试缩小窗口看看sum还能不能满足题意
                length = j-i+1;
                result = result < length ? result : length;
                sum -= nums[i++]; //不断变更i（子序列的起始位置），滑动窗口的精髓
            }
        }
        return result < INT32_MAX ? result : 0;
    }
};

思路二：暴力求解

我看了题解，认为和滑动窗口差别不是太多，差别在于暴力使用两个for循环遍历了所有情况（超时）

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result =INT32_MAX;
        int sum = 0;
        int length = 0; //窗口的长度
        
        for(int i=0; i<nums.size(); i++){
            sum = 0;
            for(int j=i; j<nums.size(); j++){
                sum += nums[j];
                if(sum >= target){
                    length = j-i+1;
                    result = result < length ? result : length;
                    break;
                }
            }
        }

        return result == INT32_MAX ? 0 : result;

    }
};

LeetCode59.螺旋矩阵II

题目链接：59. 螺旋矩阵 II

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

---

坚持循环不变量原则模拟画圈

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

由外到内一圈圈画，每一圈的四条边都要坚持一致的左闭右开或者左开右闭的原则

本文按照左闭右开的原则处理

注意圈的循环次数，如果n为奇数，那么loop=n/2只是循环一圈，矩阵中间的值需要单独处理。如果为偶数，不需要单独处理，如果n=4，则循环两圈结束

定义mid=n/2 表示n为奇数时候的中间位置，如果n=3，则中间的位置(1,1)，n=5，中间的位置(2,2)

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n,0)); //使用vector定义一个二维数组
        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就是模拟转了一圈

            //上行 从左到右，左闭右开
            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--){
                //starty此时=0，如果是左闭右闭，则j>=starty
                res[i][j] = count++;
            }
            //左列 从下到上，左闭右开
            for(; i>startx; i--){
                res[i][j]=count++;
            }

            //一个循环之后，对startxy初始化，对offset初始化
            startx ++;
            starty ++;
            offset += 1;
        }
        //如果n为奇数，单独处理
        if(n%2){
            res[mid][mid] = count;
        }
        return res;
    }
};

补充一个题目
LeetCode54螺旋矩阵
题目描述：
给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
本题就不一定是正方形了

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        //vector<int> result( (matrix.size()) * (matrix[0].size()) );
        vector<int> result;
        if(matrix.empty())
            return result;

        int upper = 0;
        int down = matrix.size()-1;
        int left = 0;
        int right = matrix[0].size()-1;
        

        while(true){
            //上行
            for( int j=left; j<=right; j++)
                result.push_back(matrix[upper][j]);
            if(++upper > down)
                break;
            //右列
            for( int i=upper; i<=down; i++)
                result.push_back(matrix[i][right]);
            if(--right <left)
                break;
            //下行
            for(int j=right; j>=left; j--){
                result.push_back(matrix[down][j]);
            }
            if(--down < upper)
                break;
            //左列
            for(int i=down; i>=upper; i--){
                result.push_back(matrix[i][left]);
            }
            if(++left > right)
                break;
        }
        return result;
    }
};