力扣学习 day2

977.有序数组的平方

题目链接：977. 有序数组的平方 - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

1）暴力破解法

直接将所有值平方再排序

参考代码：

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

PS：sort函数的简单补充

首先使用时需添加头文件#include<algorithm>

sort(begin,end,cmp)，begin为待排序的第一个元素，end为最后一个待排序元素，cmp为排序规则，不写时默认为升序排序，当需要使用降序排序时，可以将cmp写为greater<数据类型>()，例如

sort（nums.begin(),nums.end(),greater<int>()）;

2）双指针法

数组平方的最大值其实还是有规律的，数组的最左边值和最右边值平方后，它两之间的最大值就是当前数组中所有元素平方后的最大值。用指针i指向数组的最左边，指针j指向数组的最右边，当最左边元素的平方值为最大的时，将该值填入新数组的最后一位，同时i++；当最右边元素的平方值为最大的时，将该值填入新数组的最后一位，同时j--。然后再次进行比较。

参考代码：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int size = nums.size();
        int k = size - 1;
        vector <int> NewNums(size, 0);
        for (int i = 0, j = size - 1; i <= j;)/*循环增量条件省略，放到循环内部，判断条件选择<=，因为还要判断最后两个值*/
        {
            if (nums[i] * nums[i] <= nums[j] * nums[j])
            {
                NewNums[k] = nums[j] * nums[j];
                k--;
                j--;
            }
            else
            {
                NewNums[k] = nums[i] * nums[i];
                k--;
                i++;
            }
        }
        return NewNums;
    }
};

209.长度最小的子数组

 题目链接：209. 长度最小的子数组 - 力扣（LeetCode）

讲解链接：209. 长度最小的子数组 - 力扣（LeetCode）

1）暴力破解法

直接遍历所有情况，找出符合要求的数组。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int size = nums.size();
        int subLength = 0;
        int result = INT32_MAX;/*INT_MAX是个很大的数，如果想得到数组中最小值，可以先将minn设成INX_MAX, 
        这样就不需要const int定义一个很大的数了，还有很多地方都可以使用它*/
        for (int i = 0; i < size; i++)
        {
            int sum = 0;
            for (int j = i; j < size; j++)
            {
                sum += nums[j];
                if (sum >= target)
                {
                    subLength = j - i + 1;
                    result = result < subLength ? result : subLength;
                }
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

2）滑动窗口法

参考代码：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int size = nums.size();
        int subLength = 0;
        int i = 0; int sum = 0;
        int result = INT32_MAX;/*INT_MAX是个很大的数，如果想得到数组中最小值，可以先将minn设成    INX_MAX, 这样就不需要const int定义一个很大的数了，还有很多地方都可以使用它*/
        for (int j = 0; j < size; j++)//j指向子数组尾部
        {
            sum += nums[j];
            while (sum >= target)
            {
                subLength = j - i + 1;
                result = result > subLength ? subLength : result;
                sum = sum - nums[i++];//去掉滑动之后丢弃的元素
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

58.螺旋矩阵||

题目链接：59. 螺旋矩阵 II - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> LuoXuan(n, vector<int>(n, 0));
        int startX = 0; int startY = 0;//起始位置
        int offset = 1;//偏移量
        int times = n / 2;//螺旋次数
        int mid = n / 2;//中间位置
        int value = 1;//记录填充进去的值
        int x, y;
        while (times--)
        {
            x = startX; y = startY;
            for (y = startY; y < n - offset; y++)
            {
                LuoXuan[startX][y] = value++;
            }
            for (x = startX; x < n - offset; x++)
            {
                LuoXuan[x][y] = value++;
            }
            for (; y > startY; y--)
            {
                LuoXuan[x][y] = value++;
            }
            for (; x > startX; x--)
            {
                LuoXuan[x][y] = value++;
            }
            startX++; startY++;
            offset++;
        }
        if (n % 2 == 1)
        {
            LuoXuan[mid][mid] = n * n;
        }
        return LuoXuan;
    }
};