Day2 977.有序数组的平方 209.长度最小的子数组 59.螺旋矩阵II 总结

有序数组的平方

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

示例 1：

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

        非递减排序，考虑负数存在，则直接对原数组求平方，得到的数组排序顺序必然是两边大中间小，则可以比较首尾大小，将较大值放入另一个新数组的末位，然后由两侧向中间遍历，最后两个flag指向的位置必定是同一位置，也必然是最小值（可能不唯一）：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> NewArray(nums.size(),0);
        int k = nums.size()-1;
        for(int i = 0, j= nums.size()-1; i <= j; ){
        /*注意此处判定条件i=j，是因为非递减数组的最小值肯定在中间取等时
           即最小值放到新数组第一位，跳出循环*/
            if(nums[i]*nums[i]<nums[j]*nums[j]){
                NewArray[k--] = nums[j]*nums[j];
                j--;
            }
            else{
                NewArray[k--] = nums[i]*nums[i];
                i++;
            }
        }
        return NewArray;
    }
};

长度最小的子数组

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

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

        暴力法，两层for循环，依次遍历所有可能的子数组，然后依次比较每个子数组的长度大小得到，虽然肯定不能用时间复杂度这么高的方法，但是可以写出来锻炼下自己的代码能力：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int Output = INT32_MAX;//取最大值，则判断任意长度的子序列判断存在时均可使用此参考值
        int Sums = 0;
        int SubLength = 0;
        for(int i = 0; i < nums.size(); i++){
            Sums = 0;
            for(int j = i; j < nums.size(); j++){
            Sums = Sums + nums[j];
            if(Sums >= target){
                SubLength = j-i+1;
                Output = SubLength > Output ? Output : SubLength;
                break;            
            }
        }
        }
        return Output == INT32_MAX ? 0: Output;
    }
};

      接下来尝试采取之前所使用的双指针方法降低时间复杂度：取FastPtr、SlowPtr于首位，与暴力法一致，先取FastPtr从首位开始右移遍历，当首次出现Sums>=target的情况，中止遍历，然后再将SlowPtr右移，当闭区间内的Sums<target之后，再次右移FastPtr使Sums>=target，如此循环直到遍历到数组末位，即可得到子数组的最小长度：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int Output = INT32_MAX;
        int SubLength = 0;
        int Sums = 0;
        int SP = 0;
        for(int FP = 0; FP < nums.size(); FP++){
            Sums += nums[FP];
            while(Sums >= target){
                SubLength = FP-SP+1;
                Output = SubLength < Output ? SubLength : Output;
                Sums-=nums[SP++];//相当于右移SlowPtr的同时减去第一位
            }
        }
        return Output == INT32_MAX ? 0 : Output;
    }
};

        卡哥的文章称这种方法为滑动窗口法，不禁让我想起了信号处理里的加窗一词，只能说很是形象，通过比较Sums与target不停改变区间两端的方法很是巧妙，值得细细体会。

螺旋矩阵

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

示例 1：

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

        这题一看第一感觉：头皮发麻，这是否有点）

        言归正传，很显然底层逻辑就是简单的while循环，但是需要判定的边界条件过于繁杂，首先对于外圈处理，需要分为四种情况来进行讨论：向右、向下、向左、向上，为了确保一致性，取左闭右开区间，保证能够顺利闭环到最后一个元素；其次，考虑n取奇数与偶数的不同点，当n取奇数时，中间的元素是不需要考虑的，即n^2就放在最后一个地方；再次，需要考虑怎么把每一行元素有序打印下来，这个地方个人感觉难度是最大的（后面看了卡哥的方法，直接二维数组就行了，我还寻思了半天怎么打印）：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0));//定义二维数组，n个容量n的vector容器组成
        int startx = 0, starty = 0;//定义初始点，相当于坐标原点（0，0）
        int offset = 1;//定义区间控制的值
        int center = n/2;//定义中央点，即当n/2不为整数时最中间的点,比如n=5时center=2
        int loop = n/2;//循环圈数
        int count = 1;
        int i,j;
        while(loop--){
            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++;
        }
        if(n%2){
            res[center][center]=count;
        }
        return res;
    }
};

总结：

        数组是最基础的线性数据结构，但依然值得关注：

        1.循环不变量的原则：每次使用循环的时候，都需要确定循环的规则；

        2.双指针法：极大程度上解决了循环的时间复杂度问题；

        3.作图：很多看似无法解决难以理解的问题，往往作出具体的图解来便迎刃而解。