LeetCode | C++ 977.有序数组的平方 209.长度最小的子数组 59.螺旋矩阵II

977.有序数组的平方

977 题目链接
该题的话需要构建一个新的数组，在原始数组上进行操作，自己尝试写了下，太复杂，操作时间超时。构建新数组以后，即使用双指针法将元素一一加进去。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector <int> new_array(nums.size(), 0);
        int i = 0; // 左指针
        int j = nums.size() - 1;  // 右指针
        int i2, j2; // 计算左右指针对应元素的平方
        for(int k = nums.size() - 1; i <= j; k--){
            i2 = nums[i] * nums[i];
            j2 = nums[j] * nums[j];
            if (i2 >= j2) {         //两者相等时，将左边值放进去，左右其实都一样
                new_array[k] = i2;
                i++;
            }
            else {
                new_array[k] = j2;
                j--;
            }
        }
        return new_array;
    }
};

209.长度最小的子数组

209题目链接
该题主要是在每次循环中，将终止指针位置固定，然后在滑动窗口中找长度最小的子数组。同时需要注意：不要以为for里放一个while就以为是O(n^2)啊， 主要是看每一个元素被操作的次数每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i = 0;  //起始指针
        int j = 0;  //终止指针
        int sum = 0;
        int min_length = nums.size() + 1;
        int length;
        for (j = 0; j < nums.size(); j++) {
            sum = sum + nums[j];
            while(sum >= target){
                length = j - i + 1;
                min_length = (min_length < length) ? min_length : length;
                sum = sum - nums[i];
                i++; 
            }    
        }
        return (min_length == nums.size() + 1) ? 0 : min_length;
    }
};

59.螺旋矩阵II

59题目链接
该题思路并不复杂，在纸上画一个图演示下即可。在这里需要注意的是循环不变量原则，即为在循环过程中，对于每条边都遵循着一样的原则，这样写出来不容易乱。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        // 使用vector定义一个二维数组
        vector<vector<int>> nums(n, vector<int>(n, 0)); 
        
        // 每一圈的起始位置
        int start_x = 0;
        int start_y = 0;

        int count = 1;

        // 左闭右开
        // 对于每一边的结束位置定义一个 偏移量
        int offset = 1;
        int i, j;
        // 循环次数 即为 圈数
        // 若为偶数 即为 n/2
        // 若为奇数 即为 n/2  +  一个中心元素
        int circul_times = n / 2;
        while (circul_times--) {
            // (j,i) 最开始位置即为(start_y, start_x)
            i = start_x;
            j = start_y;
            // 每一圈最上边
            for (i = start_x; i < n - offset; i++) {
                nums[j][i] = count++;
            }
            // 每一圈最右边
            for (j = start_y; j < n - offset; j++) {
                nums[j][i] = count++;
            }
            // 每一圈最下边
            for (; i >= offset; i--) {
                nums[j][i] = count++;
            }
            //print(j);
            // 每一圈最左边
            for (; j >= offset; j--) {
                nums[j][i] = count++;
            }
            start_x++;
            start_y++;
            offset++;
        }
        // 若 n 为 非偶数， 则对中心的元素进行填充
        if (n % 2 != 0) {
            nums[n / 2][n / 2] = count++;
        }
        return nums;
    }
};