（第2天）【leetcode题解】977.有序数组的平方、209.长度最小的子数组

977.有序数组的平方

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

暴力解法

思路：

先平方、后排序

代码：

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;
	}
};

时间复杂度：O(n+nlogn)
空间复杂度：O(1)

双指针法

思路：

• 原数组是有序的，但负数的平方有可能大于正数的平方。
• 那么平方的最大值不是在原数组最左端，就是在原数组最右端。
• 这里借助一个新数组，通过比较原数组最左端和最右端平方得到其中的最大值，把最大的值从新数组的最右端开始向左依次赋给新数组。

代码：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> result(nums.size(), 0);//创建一个新数组
        int k = nums.size() - 1;//k初始指向新数组的最后一个元素
        for (int i = 0, j = nums.size()-1; i<=j;) {
            //i指向原数组的第一个元素、j指向原数组的最后一个元素
            if (nums[i] * nums[i] > nums[j] * nums[j]) {
                result[k] = nums[i] * nums[i];//把平方之后大的数字赋值给新数组的最后一个元素
                i++;
            } else {
                result[k] = nums[j] * nums[j];
                j--;
            }
            k--;
        }
        return result;
    }
};

时间复杂度：O(n)
空间复杂度：O(n)

209.长度最小的子数组

题目描述： 给定一个含n个正整数的数组和一个正整数target。
找出该数组中满足总和大于等于target的长度最小的连续子数组并返回其长度。
如果不存在符合条件的子数组，返回0。

暴力解法

思路：

1. 使用双循环，外层循环代表子数组的初始位置，内层循环代表子数组的终止位置，搜索所有子数组。
2. 把子数组值的总和与目标值比较，找到符合要求的子数组，并计算其长度。
3. 每找到一个符合条件的子数组，进行长度比较，把最小长度更新为要返回的结果。

代码：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result =INT32_MAX;//最终返回的最小长度
        int sum;//子序列的数值之和
        int length = 0;//子序列的长度
        for (int i = 0; i < nums.size(); i++) {
            sum = 0;
            for (int j = i; j < nums.size(); j++) {
                sum += nums[j];
                //子序列的数值之和超过目标值时
                if (sum >= target) {
                    length = j - i + 1;//子序列的长度
                    result = result < length ? result : length;//最终要返回的最小长度
                    break;
                }
            }
        }
        //如果result没有被赋值的话，说明没有符合条件的子序列，返回0
        result = result == INT32_MAX ? 0 : result;
        return result;
    }
};

时间复杂度：O(n²)
空间复杂度：O(1)

滑动窗口

思路：

1. 把要搜索的子序列想象成在原数组上滑动的窗口。
2. 在搜索子序列时，不断地移动滑动窗口的终止位置，在滑动窗口中的子数组符合要求时，更新最小长度result；
3. 然后移动滑动窗口的初始位置，直到滑动窗口再次符合要求。
4. 重复步骤2，直到把所有子序列都搜索完为止。

代码：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;//最终返回的子数组最小长度
        int sum = 0;//滑动窗口的数值之和
        int i = 0;//滑动窗口的初始位置
        int length = 0;//滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            //j代表滑动窗口的终止位置
            sum += nums[j];
            //如果出现符合条件的子数组
            while (sum >= target) {
                length = j - i + 1;//滑动窗口的长度
                result = result < length ? result : length;//更新子数组的最小长度
                sum -= nums[i++];//把滑动窗口的初始位置向后移
            }
        }
        result = result == INT32_MAX ? 0 : result;//如果result没有被赋值，返回0
        return result;
    }
};

时间复杂度：O(n)
空间复杂度：O(1)

暴力法与滑动窗口法的不同：

1. 暴力法中初始位置要移动n次，在初始位置每次移动的基础上，终止位置都要移动n次，移动的总次数为n²（近似）
2. 滑动窗口法中终止位置要移动n次，初始位置也只移动n次，移动总次数为2n（近似）