leetcode刷题（第二天）977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II ，总结

今日任务： 977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II ，总结 

卡哥建议：（1）关键在于理解双指针思想 ；

（2）本题关键在于理解滑动窗口，这个滑动窗口看文字讲解 还挺难理解的，建议大家先看视频讲解。

重点：

链接：代码随想录：代码随想录 (programmercarl.com)

977.有序数组的平方 

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

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

文章链接：代码随想录

看到题目的第一思路：冒泡排序了，

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //数组大小
        int size=nums.size()-1;
        //先平方；在排序
        for(int i=0;i<=size;i++)
        {
            nums[i]*=nums[i];
        }
        //冒泡排序--非递减
        for(int i=0;i<=size;i++)
        {
            for (int j=i+1;j<=size;j++)
            {
                if(nums[i]>=nums[j])
                {
                    int temp=nums[i];
                    nums[i]=nums[j];
                    nums[j]=temp;
                }    
            }
        }
        return nums;
    }
};

看完代码随想录之后的想法：这是容器，有算法的，不用自己苦哈哈排序

暴力解法：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {

     //先平方
        for (int i = 0; i < nums.size(); i++) {
            nums[i] *= nums[i];
        }
        sort(nums.begin(), nums.end()); // 快速排序
        return nums;
    }
};

看完代码随想录之后的想法（2）：原来还有更简单的，奥

可以说上一节的双指针法，也可以说是相向指针法；比较着前进；

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //计算数组大小；
        int size=nums.size();
        //新数组排序参数
        int k=size-1;
        //创建一个新的数组容器去接受比较完成之后的结果
        vector<int> newnums(size,0);
        //前后双指针进行行遍历每一个数据
        for(int i=0,j=size-1;i<=j;)
        {
            if(nums[i]*nums[i]<=nums[j]*nums[j])
            {
                //newnums[k]赋值后k--
                newnums[k--]=nums[j]*nums[j];
                //j--
                j--;
            }
            else
            {
                //newnums[k]赋值后k--
                newnums[k--]=nums[i]*nums[i];
                //i++
                i++;
            }
        }
        return newnums;
    }
};

自己实现过程中遇到哪些困难：for循环条件改变，写的不对，  for(int i=0,j=size-1;i<=j;)，++后置

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

209.长度最小的子数组

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

题目建议：本题关键在于理解滑动窗口，这个滑动窗口看文字讲解 还挺难理解的，建议大家先看视频讲解。

看到题目的第一思路：

文章讲解：代码随想录

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        //设置最后结果--宏定义
        int result=INT32_MAX;
        //设置一个子序列长度；
        int len=0;
        //和
        int sum=0;
        for(int i=0;i<nums.size();i++)
        {
            //重置sum
            sum=0;
            //进行下个循环并计数
                    for(int j=i;j<nums.size();j++)
                    {
                         sum+=nums[j];
                        if(sum>=target)
                        {
                            len=j-i+1;//输出子长度
                            //长度判断
                            result=result<len?result:len;
                            break;
                        }    
                    }
        }
    return result==INT32_MAX?0:result;

    }
};

 虽为暴力解法，仍然出错不少啊，在第二个循环中，

看完代码随想录之后的想法：确实简单了不少

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        //设置最后结果--宏定义
        int result=INT32_MAX;
        //设置一个子序列长度；
        int len=0;
        //和
        int sum=0;
        int i=0;
        //滑动窗口--其实也是双指针进行配合
        for(int j=0;j<nums.size();j++)
        {
            sum+=nums[j];
            //while循环重点----sum会一直--双向判断，既判断加的sum,也判断减的sum
            while(sum>=target)
            {
                len=j-i+1;
                result=result<len?result:len;
                sum-=nums[i++];//重点
            }
        }
    return result==INT32_MAX?0:result;

    }
};

自己实现过程中遇到哪些困难：while循环重点----sum会一直--双向判断，既判断加的sum,也判断减的sum；

sum-=nums[i++]；--结合while循环想；

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

相关题目

904.水果成篮 

76.最小覆盖子串

59.螺旋矩阵II

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

题目建议：本题关键还是在转圈的逻辑，在二分搜索中提到的区间定义，在这里又用上了。

文章链接：代码随想录

看到题目的第一思路：无

看完代码随想录之后的想法：奥，判断边界条件，别忘了奇数最中间的情况

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
    //首先可知n×n矩阵，进行顺时针的旋转；需要找好边界。设置二维数组
    vector<vector<int>> res(n,vector<int>(n,0));
    //记录每一圈开始位置[0][0];[1][1];[2][2];
    int startx=0;int starty=0;
    //设计循环次数
    int loop=n/2;//int向下取整；并且可知
    //边界条件，每次要-1；
    int offside=1;
    //数组赋值时，循环条件
    int i,j;
    //依次累加
    int count=1;
    //while循环判断，别忘了奇数中间位置赋值
    while(loop--)
    {
        i=startx;j=starty;//设置在for循环外侧--保持数据可用
        for(j=starty;j<n-offside;j++) //上
        {
            res[startx][j]=count++;
        }
        for(i=startx;i<n-offside;i++) //右
        {
            res[i][j]=count++;
        }

        for(;j>starty;j--) //下
        {
            res[i][j]=count++;
        }
        for(;i>startx;i--) //左
        {
            res[i][j]=count++;
        }
        startx++;
        starty++;
        offside++;//offside+=1;
    }
    //奇数中间位置赋值计算
    if(n%2)
    {
        res[startx][starty]=count;
    }
    return res;
    }
};

自己实现过程中遇到哪些困难：

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

类似题目：54螺旋矩阵

54.螺旋矩阵

• 剑指Offer 29.顺时针打印矩阵(opens new window)

 总结 

文章讲解：代码随想录

今日收获，记录一下自己的学习时长：