【代码随想录训练营】day 2 双指针、滑动窗口、螺旋矩阵

大家好，每天晚上十点我都会在小red书（yzzzzzZ）直播学习哦，相当于一个线上直播间，想要一起学习的同学可以一起哦！

977.有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size() ;
        int i = 0, j = n - 1;
        vector<int> res(n);
        int count = 1;
        while (i <= j){
            if (nums[i]  * nums[i] < nums[j] * nums[j]){
                res[n - count] = nums[j] * nums[j];
                j --;
            }
            else{
                res[n - count] = nums[i] * nums[i];
                i ++;
            }
            count ++;
        }
        return res;
    }
};

209.长度最小的子数组

滑动窗口

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        int temp = 0;
        int current_best_ans = 100001;
        int current_start_index = 0;
		// i 是指滑动窗口的右边界
        for (int i=0; i < n; i++){
            temp += nums[i];
            while (temp >= target){
                current_best_ans = current_best_ans > i - current_start_index + 1? i - current_start_index + 1 :current_best_ans;
                temp -= nums[current_start_index];
                current_start_index ++;
            }
        }
        return current_best_ans == 100001 ? 0 : current_best_ans;
    }
};

不要以为for里放一个while就以为是O(n^2)啊，
主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n
也就是O(n)。

59.螺旋矩阵II

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n));
        int num = 1;
        int cnt = 0, current_layer = 0;
        for (current_layer = 0; current_layer <= n / 2; current_layer ++){
            for (cnt = 0; cnt < n - 2 * current_layer - 1; cnt ++){
                result[current_layer][cnt + current_layer] = num++;
            }
            for (cnt = 0; cnt < n - 2 * current_layer - 1; cnt ++){
                result[cnt + current_layer][n - current_layer - 1] = num++;
            }
            for (cnt = 0; cnt < n - 2 * current_layer - 1; cnt ++){
                result[n - current_layer - 1][n - 1 - current_layer - cnt] = num++;
            }
            for (cnt = 0; cnt < n - 2 * current_layer - 1; cnt ++){
                result[n - 1 - current_layer - cnt][current_layer] = num++;
            }
        }
        if (n % 2 == 1){
            result[n / 2][n /2] = n * n;
        }
        return result;
    }
};