算法训练第二天|977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II-CSDN博客

本文链接：https://blog.csdn.net/Brillian123/article/details/135529566

有序数组的平方

题目描述：

1. 最直接的想法：先平方后排序。复杂度：O(n+logn)

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

2. 双指针法

分析一下思路：数组其实是有序的，只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。这样我们就可以通过左右两个指针从两端依次向中间靠拢来遍历数组。最开始平方大的数，就一定是最大的数！因此可以按顺序依次记录到平方大的数。

功能函数sortedSquares的返回值为一个数组，因此我们可以开辟一个结果数组用来存放平方后的结果。由于最先平方得到的值是最大的，因此我们需要倒序将这些平方后的值依次插入到结果数组中。

代码如下：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size(),0);
        int k = nums.size()-1; //定义结果数组的指针，从后往前遍历
        int left=0, right=nums.size()-1;//定义左右指针，平方后的最大值只可能在数组的两端出现
        while(left <= right) //循环终止条件如果没有等号则会丢失一个元素
        {
            if(nums[left] * nums[left] < nums[right] * nums[right])
            {
                //那么元素平方后的最大值出现在右端
                result[k] = nums[right] * nums[right]; //记录当前平方的最大值
                k--;
                right--;
            }
            else
            {
                //那么元素平方后的最大值出现在左端
                result[k] = nums[left] * nums[left]; //记录当前平方的最大值
                k--;
                left++;
            }
        }

        return result;
    }
};

长度最小的子数组

力扣链接

题目描述：

双指针法

分析：题目要求找到最小的连续子数组，则采用左右双指针法来尝试求和。

思路：

初始化两个指针 left 和 right，分别指向数组的起始位置。
初始化一个变量 sum，用于存储当前子数组的和。
遍历数组，将 right 指针向右移动，同时更新 sum。
当 sum 大于等于 target 时，记录当前子数组的长度，并尝试缩小子数组的大小（因为可能需要一直缩小范围，所以采用的while（sum >= target），即将 left 指针向右移动，同时更新 sum。
重复步骤 3-4，直到 right 指针到达数组末尾（外层循环为while(right < nums.size())）。
如果找到了满足条件的子数组，返回最小长度；否则返回 0。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        //双指针确定连续子数组求和范围
        int left=0, right=0, sum=0;
        int min_len = nums.size()+1;
        while(right < nums.size())
        {
            sum += nums[right];
            while(sum >= target)  //若区间和比target大时，尝试往后推进left，不断缩小区间
            {
                min_len = min(min_len, right-left+1);  //更新区间长度
                sum -= nums[left];  //把左侧的数字减去
                left++;  //left向前进一
            }
            right++;  //若区间和比target小，那么将right向后推进，扩大区间
        }
        return min_len==nums.size()+1 ? 0:min_len;
    }
};

代码中最小长度的初始值没有采用min_len = INT32_MAX，而是采用了nums.size()+1，因为子数组长度最大也就是nums.size()那么大。

螺旋矩阵II

力扣原题

题目描述：

螺旋矩阵遍历时，一定要坚持循环不变量原则。从外圈到内圈边界条件非常多，在一个循环中，如此多的边界条件，如果不按照固定规则来遍历每一条边，就很容易出问题，然后开始各种修修补补，最后发现改了这里那里有问题，改了那里这里又跑不起来了。。

所以，为了遍历，在所有遍历的边上采用左开右闭原则，即

对于第二圈，13和14为上面的边，13为左闭，14为右开（不包含），因此14算到(14,15)这一条边的左闭，以此类推。

这样在走每一条边的时候，避免一会左开右闭，一会左闭右闭，一会又来左闭右开。。。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> nums(n, vector<int>(n, 0));
        int startx = 0, starty = 0, offset = 1, count = 1, loop = n/2;
        int i, j;
        while(loop--)
        {
            for(j = starty; j < n-offset; j++)
                nums[startx][j] = count++;
            for(i = startx; i < n - offset; i++)
                nums[i][j] = count++;
            for( ; j > starty; j--)
                nums[i][j] = count++;
            for( ; i > startx; i--)
                nums[i][j] = count++;

            startx++;
            starty++;
            offset++;  
        }
        if(n % 2 == 1)
        {
            nums[n/2][n/2] = count;
        }
        return nums;  
           
    }


    
};