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

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

暴力法：将数组所有元素平方然后再排序（未利用题目条件：原始数组按照非降序排列）

双指针法：数组中各元素符号有三种情况：①所有元素非负（将数组中元素平方即可）、②所有元素非正（将数组中元素平方并倒序排列）、③数组中包含正数负数（数组元素平方之后最大值在数组的两端取得）。将两个指针分别指向数组首位就可以每次都取得最大值，两个指针向数组中间靠拢，将得到的结果倒序排列就得到最终结果。

在自己尝试写的过程中没有想到可以一开始就设置一个固定长度的数组，从后往前填充元素，就导致下面这段复杂的代码，在最后将数组重新倒序排列。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result;
        size_t left = 0, right = nums.size() - 1;
        while(left < right){
            if(abs(nums[left]) >= abs(nums[right])) {
                result.push_back(nums[left] * nums[left]);
                left++;
            }
            else {
                result.push_back(nums[right] * nums[right]);
                right--;
            }
        }
        result.push_back(nums[left] * nums[left]);
        left = 0;
        right = result.size() - 1;
        while(left < right){
            int temp = result[left];
            result[left] = result[right];
            result[right] = temp;
            left++;
            right--;
        }
        return result;
    }
};

修改之后：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size());
        size_t left = 0, right = nums.size() - 1, idx = nums.size() - 1;
        while(left <= right){
            if(abs(nums[left]) >= abs(nums[right])) {
                result[idx] = nums[left] * nums[left];
                left++;
            }
            else {
                result[idx] = nums[right] * nums[right];
                right--;
            }
            idx--;
        }
        return result;
    }
};

题目连接：209.长度最小的子数组

暴力法：设置两个指针，将两个指针所有可能的情况使用两层循环来遍历，选择得到长度最小的子数组。

滑动窗口：固定起始指针，向后移动终点指针，当两个指针中间元素之和(sum)大于目标值(target)之后，向后移动起始指针，直到sum<target，然后重新固定起始指针，向后移动终点指针。循环这一过程得到最终结果。

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

题目连接：59.螺旋矩阵II

卡哥的方法与本人方法不同，卡哥的方法将每一个正方形圈作为一个循环，本人在每个循环中画出正方形相邻的两条边。

从这个题目中可以注意到，画外围正方形过程中其实每两条边作为一组，首先画上边[1, 2, 3, 4]长度为4，然后右边[5, 6, 7]长度为3。这样就完成一个循环，在进入下一次循环时将需要画的边长度分别减一，比如说下边[10, 9, 8]比上边[1, 2, 3, 4]长度减一，同时左边[12, 11]比右边[5, 6, 7]长度减一。在这种循环过程中需要对填充数据的方向来进行记录。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        std::vector<std::vector<int>> vecs(n, std::vector<int>(n));
        bool right = true, down = true;
        int i = 0, j = 0, val = 1;
        while(n > 0){
            for(int k = 0; k < n; k++, val++){
                vecs[i][j] = val;
                if(right) j++;
                else j--;
            }
            if (right){
                right = false;
                j--;
                i++;
            }
            else {
                right = true;
                j++;
                i--;
            }
            n--;
            for(int k = 0; k <n; k++, val++){
                vecs[i][j] = val;
                if(down) i++;
                else i--;
            }
            if (down){
                down = false;
                i--;
                j--;
            }
            else {
                down = true;
                i++;
                j++;
            }
        }
        return vecs;
    }
};

这样写完的代码还是比较臃肿的。