代码随想录第二天｜977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II

代码随想录第二天｜977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II ，总结

LeetCode 977 有序数组的平方

题目链接： 977有序数组的平方

暴力循环思路：每个数平方后排序

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)

双指针算法思路： 数组是有序的，i指向起点，j指向终点，再开辟一个result数组存放结果， 指针k指向result的最后。如果abs(A[i]) < abs(A[j]) 那么 result[k–] = A[j] * A[j];如果abs(A[i]) > abs(A[j]) 那么 result[k–] = A[i] * A[i]

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};

时间复杂度为O(n)，相对于暴力排序的解法O(n + nlog n)还是提升不少的。

总结：双指针算法，从前向后和从后向前，不断比较数组元素大小，大的直接放进result数组

209 长度最小的子数组

题目链接209长队最小的子数组

思路 ：滑动窗口，先定窗口的右端点，再让左端点不断右移，不断比较找到最小的窗口

滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result; 
    }
};

有关INT_MAX

时间复杂度O（n）

总结：滑动窗口降低了时间复杂度，只需滑动一遍再不断比较就可以，要注意起始位置

59 螺旋矩阵II

59螺旋矩阵
思路 ：生成一个 n×n 空矩阵 mat，随后模拟整个向内环绕的填入过程

注意区间左闭右开

• 生成一个 n×n 空矩阵 mat，随后模拟整个向内环绕的填入过程：
  • 定义当前左右上下边界 l,r,t,b，初始值 num = 1，迭代终止值 tar = n * n；
  • 当 num <= tar 时，始终按照 从左到右 从上到下 从右到左 从下到上 填入顺序循环，每次填入后：
    • 执行 num += 1：得到下一个需要填入的数字；
    • 更新边界：例如从左到右填完后，上边界 t += 1，相当于上边界向内缩 1。
    • 使用num <= tar而不是l < r || t < b作为迭代条件，是为了解决当n为奇数时，矩阵中心数字无法在迭代过程中被填充的问题。

class Solution {
public:
    vector<vector<int> > generateMatrix(int n) {
        int num = 1;
        int left = 0, top = 0, right = n - 1, bottom = n - 1;

        //初始化数组
        vector<vector<int>> res(n,vector<int>(n));
        while (num <= n * n){

            //left to right
            for (int i = left; i<= right; ++i){
                res[top][i] = num ++;
            }
                ++top;
            

            //top to bottom
            for (int i = top; i <= bottom; ++i){
                res[i][right] = num ++;
            }
                --right;
            

            //right to left
            for (int i = right; i >= left; --i){
                res[bottom][i] = num ++;
            }
                -- bottom;
            

            //bottom to top
            for (int i = bottom; i >= top; --i){
                res[i][left] = num++;
            }
                ++ left;
            
        }
            return res;
        }
    
};