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

977. 有序数组的平方

题目链接：977. 有序数组的平方
注意事项：

• 主要是使用双指针法
• vector容器被简单定义后不能直接使用方括号的形式赋值，需要提前在这个位置有元素或者空位，再进行赋值

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> r(nums.size()); //此处对返回数组进行创建，需要指定容器的大小
        int left = 0, right = nums.size() - 1;
        int i = nums.size() - 1;
        while(left <= right){
            int a = nums[left] * nums[left];
            int b = nums[right] * nums[right];
            if(a <= b){
                r[i--] = b;
                right--;
            }else{
                r[i--] = a;
                left++;
            }
        }
        return r;
    }
};

209. 长度最小的子数组

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

• 暴力解法，双重for循环，会超时

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int r = nums.size(), ans;
        for(int i = 0; i < nums.size(); i++){
            int temp = 0, ans = 0;
            for(int j = i; j < nums.size(); j++){
                ans += nums[j];
                temp++;
                if(ans >= target){
                    if(temp < r){
                        r = temp;
                    }
                    break;
                }
                if(i == 0 && j == nums.size() - 1){
                    return 0;
                }
            }
        }
        return r;
    }
};

• 快慢指针，滑动窗口

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left = 0, right = 0, flag = 0;
        int ans = 0, count = 0, r = nums.size();
        for(right = 0; right < nums.size(); right++){ //快指针从头到尾依次遍历
            ans += nums[right];
            while(ans >= target){ //慢指针会在窗口的和大于target时移动，每移动依次将从和中减去对应位置的值
                count = right - left + 1;
                if(count < r){ //选取最小的子数组
                    r = count;
                }
                ans -= nums[left++];
                flag = 1;
            }
        }
        if(r == nums.size() && flag == 0){ //判断一次是否大于等于过target，如果没有说明数组全部数字相加小于target
            return 0;
        }
        return r;
    }
};

59. 螺旋矩阵 II

题目链接：59. 螺旋矩阵 II
注意事项：

• 记住整体的实现顺序
• 对于边界问题作出判断

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int> > r(n, vector<int>(n, 0));

        if(n == 1){
            r[0][0] = 1;
            return r;
        }
        int startx = 0, starty = 0; //初始移动位置
        int count = 1; //计数
        int offset = 1; //每次遍历完成一圈，下次再次进行下一圈时循环的次数减一
        int mid = n / 2;
        int loop = n / 2; //总循环的次数

        while(loop--){
            int i = startx;
            int j = starty;

            for(; j < n - offset; j++){
                r[i][j] = count++;
            }

            for(; i < n - offset; i++){
                r[i][j] = count++;
            }

            for(; j > starty; j--){
                r[i][j] = count++;
            }

            for(; i > startx; i--){
                r[i][j] = count++;
            }

            startx++; //下次起始点位置改变
            starty++; //同上
            offset++; //n-offset会减一
        }
        if(n % 2){
            r[n / 2][n / 2] = count; //处理在n为奇数时，中间点的数值
        }
        return r;
    }
};

数组总结

1. 对于顺序数组字样的题目首先想到二分思想，如果是非顺序的数组，先排序再利用二分考虑是否会降低时间复杂度
2. 对于二分查找几个关键点的书写最为重要，需要考虑当前实现的是怎样的开闭区间
3. 二分查找在需要舍去元素时，考虑边界位置的元素是否符合要求
4. 二分查找如果进入死循环，首先检查边界处理条件
5. 双指针法可以考虑快慢指针、同向指针、对向指针，凡是需要两个位置产生关联的题目需要考虑此种方式
6. 涉及数组的题目特别注意在对数组边界的处理，到底需要不需要减一是在考虑的范围内