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

本文链接：https://blog.csdn.net/sdfg346777/article/details/135262943

本文介绍了如何解决LeetCode中的两个问题：有序数组的平方，通过暴力解法和双指针优化，以及长度最小的子数组问题，通过暴力遍历和滑动窗口方法。还探讨了螺旋矩阵生成的思路，通过模拟顺时针绘制过程实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

LeetCode 977 有序数组的平方

题目要求：

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

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

方法一：暴力解法

思路：依次将数组中的每个元素进行平方，再用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;
    }
};

方法二：双指针法

思路：由于已给的数组nums是一个非递减顺序，所以进行平方后，最大值一定是最左边或者最右边的，根据这个思路，在最左边和最右边各设定一个指针，比较指针所指元素的大小，然后，左边指针的元素小就向右移，右边指针的元素小就向左移，左边指针和右边指针指的数不相等时，正常赋值，移动指针，如果出现两边指针指的数相等时，有可能是数组中只有一个数，也有可能是互为相反数，这两种情况需要区分考虑。（这是没有看解析之前的想法，看了解析之后发现这种方法太麻烦）

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size(),0);
        int leftindex = 0;
        int rightindex = nums.size()-1;
        for(int i = nums.size()-1; i>=0;i--){
            cout << leftindex << rightindex;
            if(nums[leftindex]*nums[leftindex] < nums[rightindex]*nums[rightindex]){
                result[i] = nums[rightindex]*nums[rightindex];
                rightindex --;
                continue;
            }
            if(nums[leftindex]*nums[leftindex] > nums[rightindex]*nums[rightindex]){
                result[i] = nums[leftindex]*nums[leftindex];
                leftindex ++;
                continue;
            }
            if(nums[leftindex]*nums[leftindex] == nums[rightindex]*nums[rightindex]){
                if(leftindex == rightindex){
                    result[i] = nums[rightindex]*nums[rightindex];
                }
                else{
                    result[i] = nums[rightindex]*nums[rightindex];
                    rightindex --;
                }
                continue;
            }
        }
        return result;
    }
};

如果将左指针小于等于右指针这个条件，作为while循环结束的条件，程序就可以简单很多（这里本来考虑太多了，以为数组只有一个元素的时候，如果写j--就会变成-1，超出索引范围，导致报错，但是这个时候i<=j就不成立了，不会继续循环，所以不会导致这个问题）

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
         int k = A.size() - 1;
         int i= 0;
         int j = A.size() - 1;
        vector<int> result(A.size(), 0);
        while (i <= j) { 
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k] = A[j] * A[j];
                k--;
                j--;
            }
            else {
                result[k] = A[i] * A[i];
                k--;
                i++;
            }
        }
        return result;
    }
};

209.长度最小的子数组

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

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

方法一：暴力解法

思路：先固定起点，挨个试，以第一个元素为起点，需要几个元素可以超过要求的和，以第二个为起点，需要几个......

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;
    }
};

方法二：滑动窗口

思路：只循环重点的位置，记录大于设定值的长度，记录后更新起点位置（这里没有想到的一个点是，判断和是否大于target时，应该用while循环，而不是if判断，思考的时候先入为主的认为应该用if判断，想不出来当变更起始位置后，要怎么不加后一个数值得情况下，再判断一次）

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

59.螺旋矩阵

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

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

思路：

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

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

由外向内一圈一圈画

采用左闭右开，每次给n-1个格子赋值，最后不能忘记如果是奇数的话，需要单独给中间的值赋值。（这里我容易错的点是，需要注意要单独设定startx和starty这两个值，方便需要循环多轮的时候，更改起始值，还有设置offset，控制每次遍历的长度）

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;
        int offset = 1;
        int count = 1;
        while(loop--){
            int i = startx;
            int j = starty;
            for(j = starty;j < n - offset;j++){
                res[i][j] = count;
                count ++;
            }
            for(i = startx;i < n - offset;i++){
                res[i][j] = count;
                count ++;
            }
            for(;j > starty;j--){
                res[i][j] = count;
                count ++;
            }
            for(;i > startx;i--){
                res[i][j] = count;
                count ++;
            }
            offset += 1;
            startx += 1;
            starty += 1;
        }
        if(n % 2){
            res[n/2][n/2] = n*n;
        }
        return res;
    }
};