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

LeetCode 977.有序数组的平方

题目链接：977. 有序数组的平方 - 力扣（LeetCode）

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

思路

看了这道题第一眼想到的就是把每个数都先平方一遍，然后排个序，简单暴力就解决了问题。

一、暴力排序的写法：

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

·时间复杂度：O（n + nlogn)

二、双指针法：

思路

这里指针s指向起始位置，f指向终止位置，两个指针同时向这个数组中间移动，定义一个新数组和原来数组的大小一样，让a指向数组终止位置。

如图所示：

代码实现：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {  
            int ans = nums.size() - 1;
    vector<int> Array(nums.size(),0);
        for(int s = 0,f = nums.size() - 1;s <= f;) {
            if(nums[s] * nums[s] < nums[f] * nums[f]) {
                Array[ans] = nums[f] * nums[f];
                ans--;
                f--;
            }
            else {
                Array[ans] = nums[s] * nums[s];
                ans--;
                s++;
            }
        }
        return Array;
    }
};

这里代码需要注意的是：在for循环中s<=f，因为最后要处理两个元素，如果没有=就会落一个元素。

·时间复杂度：O（n）

LeetCode 209.长度最小的子数组

题目链接：209. 长度最小的子数组 - 力扣（LeetCode）

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

思路

看到这个题，不出意外的，我还是想到简单暴力的两层for循环，一个负责控制起始位置，另一个就是负责控制终止位置，然后都循环遍历一遍，找到符合条件的子序列。其实我也想到了指针，用一个for循环完成两个for循环的事，我就寻思在for循环中，那个终止位置一个一个往后移，然后再循环的话，就和暴力解法没区别了，都是一个一个找的，这就一下子给我整蒙了，所以说自己思考的时候，我没有理解这道题的灵魂。

一、暴力解法：

代码实现：

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

·时间复杂度：O(n^2)

·空间复杂度：O(1)

二、滑动窗口：（数组中另一个重要的方法）

滑动窗口就是说通过不断的调节子数列的起始位置和终止位置，从而得出我们的结果。

滑动窗口的灵魂就是如何移动起始位置！！首先先让终止位置向后移，到了满足条件的时候，再去移动起始位置就可以。以数组[2,3,1,2,4,3]为例，s=7，最后找到4，3为最短距离。

如图所示

 滑动窗口的精妙之处就在于根据当前子序列和大小的情况，不断调节子序列的起始位置。

代码实现：

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

·时间复杂度：O(n）

·空间复杂度：O（1)

LeetCode 59.螺旋矩阵

题目链接：59. 螺旋矩阵 II - 力扣（LeetCode）

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

思路

我看到这题的第一眼就觉得这题绝对很麻烦，肯定会有好多边界条件啊、循环啊什么的，很容易蒙。

但是本题并不涉及到什么算法，就是模拟过程，但却十分考察对代码的掌控能力。对本题求解就像写二分法一样，要坚持循环不变量原则，这里我用左闭右开原则，先从左到右，然后从上到下，再然后从右到左，最后从下到上，就像下图所示一样

代码实现： 

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
     vector<vector<int>> matrix(n,vector<int>(n,0));
        int i;
        int j;
        int starx = 0;
        int stary = 0;
        int offset = 1;//每次循环右边界收缩一位
        int count =1;
        int loop = n / 2;//loop指绕的圈数
        int mid = n / 2;//矩阵的中间位置
        while(loop--) {
            i = starx;
            j = stary;
          for(j = stary;j < n - offset;j++) {//从左到右
            matrix[starx][j] = count++;
          }
          for(i = starx;i < n - offset;i++) {//从上到下
              matrix[i][j] = count++;
          }
          for(;j >stary;j--) {//从右到左
              matrix[i][j] = count++;
          }
          for(;i > starx;i--) {//从下到上
              matrix[i][j] = count++;
          }
          starx++;
          stary++;
          offset+= 1;
        }
        if(n % 2 != 0) {
            matrix[mid][mid] = count;
        }
        return matrix;
    }
};

·时间复杂度：O(n^2):模拟遍历二维矩阵的时间

·空间复杂度：O(1)