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

 977.有序数组的平方 

题目建议： 本题关键在于理解双指针思想 

题目链接：力扣

文章讲解：代码随想录

视频讲解： 双指针法经典题目 | LeetCode：977.有序数组的平方_哔哩哔哩_bilibili

这道题，我的第一想法是先让每个元素平方，再对数组进行排序（使用选择排序法），再次不多赘述，代码如下： 

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n=nums.size();
        int temp,j,min;
        for(int i=0;i<n;i++)
        {
            nums[i]=nums[i]*nums[i];
        }
        for(int i=0;i<n;i++)
        {
            min=i;
            for(j=i+1;j<n;j++)
            {
                if(nums[min]>nums[j])
                {
                    min=j;
                }
            }
            temp=nums[i];
            nums[i]=nums[min];
            nums[min]=temp;
        }
        return nums;
    }
};

当然，还可以更暴力一点，使用sort函数，代码如下

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

还可以使用双指针法解决

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n=nums.size();
        int k=n-1,j=n-1;
        vector<int> result(n, 0);
        for(int i=0;i<=j;)//i,j分别为左边界和右边界的下标
        {
            if(nums[i]*nums[i]<nums[j]*nums[j])
            {
                result[k--]=nums[j]*nums[j];
                j--;
            }
            else
            {
                result[k--]=nums[i]*nums[i];
                i++;
            }
        }
        return result;
     }
};

由于原来是按照非递减顺序排列的，平方后，元素大小为两边大，中间小，所以可以设置双指针，比较首尾大小，把大的放进新数组中，并缩小边界。

 209.长度最小的子数组

题目链接：力扣

文章讲解：代码随想录

视频讲解：拿下滑动窗口！ | LeetCode 209 长度最小的子数组_哔哩哔哩_bilibili

第一想法自然就是纯暴力，用两个for循环，一个作为起点，一个作为终点，不断右移直到满足条件，代码如下：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX; // 最终的结果
        int sum = 0; // 子序列的数值之和
        int len = 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
                    len = j - i + 1; // 取子序列的长度
                    result = result < len ? result : len;
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

这道题还可以用滑动窗口的思想来做

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i=0;//起点
        int sum=0,len;
        int result = INT32_MAX;
        for(int j=0;j<nums.size();j++)//终点先移动
        {
            sum+=nums[j];
            while(sum>=target)
            {
                len=j-i+1;
                result=result>len?len:result;
                sum-=nums[i];//删除起点的值
                i++;//移动起点
            }
        }
        return result==INT32_MAX?0:result;
    }
};

（浅浅盗一下卡哥的图）

滑动窗口的思想与双指针有一些相似，其精湛之处在于可以改变起点的位置，当终点不断右移直到满足条件后，移动起点。实际上，滑动窗口就是暴力的一种优化，将起点移动，避免了很多不必要的运算，从而节省了时间。

 59.螺旋矩阵II

题目链接：力扣

文章讲解：代码随想录

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

 

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); 
        int qx=0,qy=0;//每次循环的起点，且都在对角线上
        int mid=n/2;//奇数倍的方阵会存在一个中间值
        int count=1;
        int num=n/2;//循环的次数
        int offset=1;//每循环一层，边上就要少1
        int i,j;
        while(num!=0)
        {
            num--;
            for(j=qy;j<n-offset;j++)//左闭右开，若要左开右闭，代码为for(j=qy+1;j<=n-offset;j++)
            {
                res[qx][j]=count++;
            }
            for(i=qx;i<n-offset;i++)
            {
                res[i][j]=count++;
            }
            for(j=n-offset;j>qy;j--)
            {
                res[i][j]=count++;
            }
            for(i=n-offset;i>qx;i--)
            {
                res[i][j]=count++;
            }
            qx++;
            qy++;
            offset++;
        }
        if(n%2!=0)
        {
            res[mid][mid]=count++;
        }
        return res;
    }
};

这道题不含什么特殊算法，其实就是一个对过程的分析，可以多画图有助于理解。

Day 2打卡完成，耗时3.5小时。