代码随想录算法训练营第二天| LeetCode977 有序数组的平方、LeetCode209 长度最小的子数组、LeetCode59 螺旋矩阵

977.有序数组的平方

思路：先对数组中所有元素取平方，然后重新排序。（冒泡排序忘了怎么写了，直接调用的size）

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //暴力解法
        //先平方，再排序
        for (int i = 0;i<nums.size();i++)
        {
            nums[i] = nums[i]*nums[i];
        }
        sort(nums.begin(),nums.end());
    return nums;
    }
};

看完题解后思路：双指针法，首位指针对应的元素平方同时比较，将大的元素放入新的数组末端，移动指针。（左闭右闭）

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

209.长度最小的子数组

思路：暴力解法，寻找数组中所有和大于target的子数组，并计算长度，如果长度更小，就替换原长度值。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
 int result = INT32_MAX; // 最终的结果
        int sum = 0; // 子序列的数值之和
        int subLength = 0; // 子序列的长度
        for (int i = 0; i < nums.size(); i++) { // 设置子序列起点为i
            sum = 0;
            for (int j = i; j < nums.size(); j++) { // 设置子序列终止位置为j
                sum += nums[j];
                if (sum >= s) { // 一旦发现子序列和超过了s，更新result
                    subLength = j - i + 1; // 取子序列的长度
                    result = result < subLength ? result : subLength;
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

看完题解后思路：滑动窗口法，用两个指针，包含住一个窗口，如果窗口内的元素的和大于target，则记录长度（比较，替换），滑动窗口起点移动，重新判断，直到遍历完整个数组。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        //滑动窗口法
        int result = INT32_MAX;
        int size = 0;
        int i=0;//滑动窗口起点
        int sum = 0;
        for(int j = 0;j<nums.size();j++)
        {
            sum +=nums[j];
            while(sum>=target)
            {
                size = j-i+1;
                result = result<size ? result:size;
                sum -=nums[i++];
            }

        }
        return result==INT32_MAX?0:result;
    }
};

这里result=INT32_MAX;可以用来判断如果数组中没有满足条件的子序列，result的值就没有被修改过，即返回0。

59.螺旋矩阵

思路：转圈循环，但循环写的卡住了。

看完题解后思路：转圈循环，确定需要转的圈数，以及每条边的边界条件，在每圈的循环中应保持一致。（利用offset），且n为奇数时，应单独对中心的点赋值。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n,vector<int>(n,0));
        int startx = 0,starty =0;
        int loop = n/2;//转的圈数
        int offset = 1;//控制循环的终止位置
        int count = 1;
        while(loop)
        {
            int i = startx;
            int j = starty;
        for( j = starty;j < n-offset;j++)
        {
            res[startx][j] = count++;
        }
        for( i = startx;i<n-offset;i++)
        {
            res[i][j] = count++;
        }
        for(;j>starty;j--)
        {
            res[i][j] = count++;
        }
        for(;i>startx;i--)
        {
            res[i][j] = count++;
        }
        startx++;
        starty++;
        offset++;
        loop--;
        }
        if(n%2 ==1)
        {
            res[n/2][n/2] =n*n;
        }
        return res;
    }
};

收获：

1、复习冒泡排序。

2、学习了滑动窗口法。

3、nxn的二维数组的创建为vector<vector<int>> 变量名(n,vector<n,0>),且对数组元素赋值时，应该为变量名[ ][ ] = ,在编程中我写成了变量名[ , ]，一直在报错，没有看出来。