算法day2-力扣977-力扣209-力扣59

力扣977-有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

暴力解法-for循环遍历数组中所有元素，对元素进行平方，再使用快速排序对数组进行排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for(int i=0;i<nums.size();i++) //遍历数组中所有元素
        {
            nums[i]*=nums[i]; //每个元素进行平方
        }
        sort(nums.begin(),nums.end()); //快速排序，重新对数组进行排序
        return nums; //返回数组
    }
};

双指针解法-题目是有序数组，存在负数，负数的平方可能大于正数的平方，因此存在左右边界。对于左右边界，可以采用双指针解法，分别计算左边界和右边界的平方的值，对比之后，将较大的值存入新数组，然后改变对应的边界的值和新数组的下标。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k=nums.size()-1;
        // 创建一个新数组，有nums.size()个为0的元素
        vector<int> result(nums.size(),0); 
        //定于数组左右边界的指针i，j
        for(int i=0,j=nums.size()-1;i<=j;)
        {
            //如果右边界的元素的平方较大，则写入新数组，并改变右边界和新数组下标
            if(nums[i]*nums[i]<nums[j]*nums[j])
            {
                //写入新数组，然后改变新数组下标
                result[k--]=nums[j]*nums[j];
                //改变右边界
                j--;
            }
            //如果左边界的元素的平方较大，则写入新数组，并改变左边界和新数组下标
            else
            {
                //写入新数组，然后改变新数组下标
                result[k--]=nums[i]*nums[i];
                //改变左边界
                i++;
            }
        }
        return result; //返回新数组
    }
};

力扣209-长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

暴力解法- 两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是O(n^2)。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result=INT32_MAX; //定义结果为int型最大值
        int sum=0; //子序列之和
        int len_result=0; //子序列的长度
        for(int i=0;i<nums.size();i++) //第一层循环
        {
            sum=0; //重置子序列之和
            for(int j=i;j<nums.size();j++) //第二层循环，从i开始的子序列
            {
                sum+=nums[j]; //从i开始到j的子序列之和
                if(sum>=target) //大于目标值
                {
                    len_result=j-i+1; //计算子序列长度
                    //如果结果小于子序列长度，则结果不变，反之，结果等于子序列长度
                    result=result<len_result?result:len_result;
                    break; //跳出循环
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

滑动窗口-双指针解法，i为滑动窗口起始位置，j为滑动窗口终止位置，从i为0开始计算到j的子序列之和，当sum大于等于目标值时，循环判断sum是否大于target，计算滑动窗口长度并改变滑动窗口的起始位置（i+1），同时之前计算得出的sum要减掉数组中i的值（nums[i]）。例如数组为{1，1，1，1，1，100}，target为100，第一个满足条件的子序列是从0-5，sum为105，长度为6；滑动窗口就不改变终止位置，改变起始位置，第二个子序列就是从1-5，sum为104，长度为5。当当前子序列sum之和不大于target时，则j+1，即滑动窗口的终止位置向后移动，sum+=nums[j]，直到sum大于target，然后又会移动滑动窗口的起始位置。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result=INT32_MAX; //定义结果为int型最大值
        int sum=0; //子序列之和
        int len_result=0; //子序列的长度
        int i=0; //滑动窗口起始位置
        for(int j=0;j<nums.size();j++) //滑动窗口终止位置
        {
            sum+=nums[j]; //子序列之和
            while(sum>=target) //循环判断sum是否大于target
            {
                //计算子序列长度
                len_result=j-i+1;
                //如果结果小于子序列长度，则结果不变，反之，结果等于子序列长度
                result = result < len_result ? result : len_result;
                //改变滑动窗口起始位置，i加1，子序列就从i的下一位开始计算，因此sum要减去nums[i]
                sum=sum-nums[i];
                i++;
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

力扣59-螺旋矩阵

给你一个正整数 n ，生成一个包含 1 到 n x n 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

坚持循环不变量原则，坚持了每条边左闭右开的原则。处理矩阵边的时候最后一个点留给下一条边处理。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        int startx=0,starty=0; // 定义每循环一个圈的起始位置
        // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int loop = n / 2;  
        // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int mid = n / 2;
        int count=1; // 用来给矩阵中每一个空格赋值
        int offset=1;  // 需要控制每一条边遍历的长度，每次循环右边界收缩一位

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

            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for(j=starty;j<n-offset;j++)
            {
                res[starty][j]=count++;
            }
            //此时，j等于n-offset，即上行的最后一个空格
            // 模拟填充右列从上到下(左闭右开)
            for(i=startx;i<n-offset;i++)
            {
                res[i][j]=count++;
            }
            //此时i，j是矩阵右下角的值，即（n-offset，n-offset）
            // 模拟填充下行从右到左(左闭右开)
            for(;j>starty;j--)
            {
                res[i][j]=count++;
            }
            //此时，j为循环矩阵的左下角的空格
            // 模拟填充左列从下到上(左闭右开)
            for(;i>startx;i--)
            {
                res[i][j]=count++;
            }
        // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startx++;
            starty++;
            offset++;

        }
        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};