打卡第二天 977. 有序数组的平方、209. 长度最小的子数组、59.螺旋矩阵II

打卡第二天 977. 有序数组的平方、209. 长度最小的子数组、59.螺旋矩阵II

977.有序数组的平方

看到题目首先想到暴力解法，即对每个数组里的值求平方，然后排序即可

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result;
        int size = nums.size();
        for (int i=0;i<size;i++) {
            result.push_back(nums[i] * nums[i]);
        }
        sort(result.begin(), result.end());
        return result;
    }
};

通过看代码随想录可以发现，这道题还能够使用双指针法解决，因为两端的数字平方之后还在两端，所以使用两个指针分别指向两端，平方后比较大小，大的放入结果数组相应的位置即可

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

209.长度最小的子数组

看到题目首先想到可以使用暴力解法，使用两个for循环遍历所有的子数组的情况即可解决。

然后看了代码随想录里面的解法，学了一下滑动窗口法，和双指针的思想是一样的，也是用了两个指针。

用一个快指针指向后面的元素，元素不断累加，然后得到大于目标值的一串数组，之后让指向开始的慢指针也累加，最终求出结果，代码如下。

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

59.螺旋矩阵II

主要是控制好边界的条件，每条边都设置为左闭右开，即最后一个点不处理，然后循环的过程中要注意增加offset和startx、starty，代码如下。

 vector<vector<int>> generateMatrix(int n) {
        // 使用vector定义一个二维数组
        vector<vector<int>> result(n, vector<int>(n, 0)); 
        // 起始位置
        int startx = 0, starty = 0; 
        //循环次数
        int loop = n / 2;
        //中间的位置
        int mid = n / 2; 
        //给矩阵中空格赋值
        int count = 1; 
        // 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int offset = 1; 
        int i,j;
        while (loop --) {
            i=startx;
            j=starty;

            //开始循环
            //从左往右填充，最右边的不处理
            for(j=starty;j<n-offset;j++)
            {
                result[startx][j]=count++;
            }
            //从上往下填充，最下边的不处理
            for(i=startx;i<n-offset;i++)
            {
                result[i][j]=count++;
            }
            //从右往左填充，最左边的不处理
            for(;j>starty;j--)
            {
                result[i][j]=count++;
            }
            //从下往上填充，最上边的不处理
            for(;i>startx;i--)
            {
                result[i][j]=count++;
            }

            startx++;
            starty++;
            offset++;
           
        }

        if(n%2)
        {
            result[mid][mid]=count;
        }
        return result;
    }

今天的题大概就是这样，掌握的不是很好，明天看看链表。