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

977.有序数组的平方

题目链接：. - 力扣（LeetCode）

文章讲解：代码随想录

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

状态：想到了暴力解法，但没有想到双指针，看了提示后，也并没有想出双指针该怎么写

 解题思路：

1.暴力解法

比较容易想到的一种解法，先对整个数组的每个元素进行平方操作，再用sort排序即可

代码实现

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

时间复杂度：O(n+log n)

2.双指针法

与之前移除元素不同，这次的双指针一个在头，一个在尾，因为这是一个非递减数组，因此数字的头和尾都是较大的数，而中间的是较小的数，两个指针都是来寻找新数组的元素，用定义的元素k来记录下标位置，因为双指针一开始都是较大的数比较，因此k应从新数组的尾部开始记录

代码实现

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
           vector<int> result(nums.size(),0);
           int k = nums.size()-1;
           for(int i=0,j=nums.size()-1;i<=j;)    //i<=j,因为要处理最后两个元素，等ij相等是最后一个
           {
                if(nums[i]*nums[i]>nums[j]*nums[j])
                {
                    result[k--] = nums[i]*nums[i];
                    i++;
                }
                else
                {
                    result[k--] = nums[j]*nums[j];   //这里包含了ij相等的情况，和元素相同的情况，用哪个去记录都可以
                    j--;
                }
           }
           return result;
    }
};

时间复杂度：O(n) 

总结

双指针思想不限于单个指针去寻找新数组元素，单个指针标记下标，根据这个含有负数平方的数组特性，可以利用两个指针分别去寻找新元素，本题关键在于理解数组的特性，在套用双指针。

209.长度最小的子数组

题目链接：. - 力扣（LeetCode）

文章讲解：代码随想录

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

解题思路：

1.暴力解法

 我的这个暴力解法，并不能过所有的用例，时间复杂度比较大，超出时间限制了，仅供参考

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

时间复杂度：O(n^2)  不太会算，不知道对不对

2.滑动窗口（双指针）

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
          int i=0;     //滑动窗口的起始位置
          int result = INT32_MAX;    //记录最小长度
          int sum = 0;      //滑动窗口中的元素和
          int minLen = 0;    //记录最小长度的临时变量
          for(int j=0;j<nums.size();j++)
          {
             sum+=nums[j];       //不断扩大窗口，来寻找大于等于target的窗口
             while(sum>=target)    //当窗口满足条件后，要通过移动初始窗口来缩小窗口范围，寻找最小的窗口
             {
                sum-=nums[i];    //移动窗口
                minLen=(j-i+1);   //记录此时的最小长度
                result = result<minLen?result:minLen;   //最终结果的记录
                i++;   //起始位置往前移动
             }
          }
          return result==INT32_MAX?0:result;   //最终返回结果，没有找则返回0
    }
};

时间复杂度：O（n）

空间复杂度：O（1）

总结

本题在于理解滑动窗口是什么，和双指针来实现的滑动窗口。

窗口是什么？

是由起始位置和终止位置之间的元素加起来，符合条件的数组

如何以及为何移动起始位置? 

当我们移动终止位置，扩大窗口后，找到满足条件的数组后，我们要去寻找他的子数组是否满足条件，去找到那个最小的子数组，同理找最大时，是i--，通过满足初始条件后的回退找最大

如何以及为何要移动终止位置？

因为我们要扩大窗口，去寻找满足条件的数组，这是通过外层循环来实现的

这里通过卡哥的一张图来具象化理解

但是当我们需要找最大的时候，和这个相反，i应该是要--，进行回退到最大，因此一般找最大是当不符合条件是，i要到j的左边几个固定的位置，再进行回退找最大

59.螺旋矩阵II

解题思路

这题比较重要的是，规定好每条边是如何进行操作的，找到一个循环不变量，那么就是左闭右开的处理方式，对于每一条边，此时是要知道这个矩阵转了多少圈，并设置一个变量记录这个圈数，以便后续做边界的处理（我没有想到的地方），整体代码不难，主要是理清思路

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
            vector<vector<int>> res (n,vector<int>(n,0));
            int mid = n/2;     //当n为奇数时，中间的那个元素直接利用mid填入即可
            int loop = n/2;    //转多少圈
            int startX=0;
            int startY=0;     //起始位置
            int offest = 1;   //正在转第几圈，用于后续减去已经转过的圈数
            int count =1;    //用于计数
            int i,j;
            while(loop--)
            {
                i=startX;
                j=startY;
                for(;j<n-offest;j++)
                   res[i][j] = count++;
                for(;i<n-offest;i++)
                   res[i][j] = count++;
                for(;j>startY;j--)
                   res[i][j] = count++;
                for(;i>startX;i--)
                    res[i][j] = count++;
                offest+=1;    //转完一圈了
                startX+=1;
                startY+=1;   //更新新的一圈的初始位置
            }
            if(n%2==1)
              res[mid][mid]=count;
            return res;
    }
};

时间复杂度：O（n^2）  模拟了二维矩阵的构建

空间复杂度：O（1）

今日收获

今天的题目两道都有思路，但都不是最优解，学习和认知到了双指针思想，加深了一下理解，也学到了滑动窗口的思想，以后之后也可以收获多多！数组章节应该是结束啦ヾ(◍°∇°◍)ﾉﾞ