977.有序数组的平方

leetcode题目链接

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
示例 1：输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为[16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]
示例 2： 输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

能写出暴力解法，先计算平方然后再排序。嗯，sort函数真好用。O（n+nlogn）

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

根据提示我自己写的双指针解法，能对一部分但是并不完全正确。

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

正确解法。时间复杂度为O(n)

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        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;
    }
};

根据代码随想录的解答修改我自己的答案

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int size = nums.size();
        int k = size - 1;
        vector<int> result(nums.size(), 0);
        for(int a = 0, b=size-1; b>=a;){//重点：这里需要=号。两个指针可以定义在for循环里（a和b）。终止条件都可以是变量。
            if(nums[a]*nums[a]>nums[b]*nums[b]){
            result[k--] = nums[a]*nums[a];//学习这种每一步赋值后都要往前一步的写法，即k--
            a++;//终止条件的变量可以写在for的函数体里面。
            }else{
                result[k--] = nums[b]*nums[b];
                b--;//同上。
            }
        }
        return result; 
    }
};

---

209.长度最小的子数组

leetcode题目链接

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续
子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

我自己看着代码随想录滑动窗口（本质是双指针）解法的那个动态图来写的。能通过leetcode中2，3示例，所以我这个写法得到的结果是从左到右第一个符合条件的子数组，但不是最小子数组。
我一开始看错题目了，我以为要计算的是等于target的最小子数组，其实题目是要大于等于。所以下面我写的代码也不是符合题目要求的。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int N;
        for(int i = 0, j = 0; i<nums.size() - 1;){
            //计算i和j之间的数组和(只能用循环计算吗)
            N = 0;
            for(int a = i; a <= j; a++){
                N = N + nums[a];
            }
            if(N == target){
                return j - i + 1;
            }
            if(N < target){
                j++;
            }
            if(N > target){
                i++;
            }
            if(j > nums.size() - 1){
                break;
            }
        }
        return 0;
    }
};

抄的代码随想录的暴力解法

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0;
        int subLength = 0;
        for (int i = 0; i<nums.size(); i++){
            sum = 0;
            for(int j = i; j<nums.size(); j++){
                sum = sum + nums[j];
                if(sum >= target){
                    subLength = j - i + 1;
                    result = result < subLength ? result : subLength; //这个倒是可以解决我上面那个不能找最小数组的缺陷，但是这个是需要找到全部的组合，估计只能适合暴力解法。
                    break;
                }
            }
        }
        return result==INT32_MAX ? 0 : result;
    }
};

代码随想录中，从暴力解法优化来的滑动窗口解法。

//这个滑动窗口代码是从暴力解法优化过来的，很有思考价值
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0;
        int subLength = 0;
        int i = 0;//加的
        for (int j = 0; j<nums.size(); j++){ //i变成j，外层for循环控制结束位置
            sum = sum + nums[j];
            while(sum >= target){//把原本if的判断写在了while的执行条件里
                subLength = j - i + 1;
                result = result < subLength ? result : subLength;
                sum = sum - nums[i++];//这里其实做了两件事，一个是动态去掉了滑动窗口的前面一个数组值，即缩小滑动窗口，另一个是将指针i后移。嗯，我发现作者好像很喜欢这种数组里取值再直接加减的写法，确实很简洁，可以学学。
            }
            //下面注释的是暴力解法
            // for(int j = i; j<nums.size(); j++){
            //     sum = sum + nums[j];
            //     if(sum >= target){
            //         subLength = j - i + 1;
            //         result = result < subLength ? result : subLength;
            //         break;
            //     }
            // }
        }
        return result==INT32_MAX ? 0 : result;
    }
};

---

59.螺旋矩阵II

leetcode题目链接

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

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

有个疑问，二维数组的题目是不是至少都是O（n^2）的时间复杂度？

这个题没有算法，就是纯模拟。重要的是处理四个边界都要坚持左闭右开。循环不变量。

总结

数组这一章学习了二分法和双指针法（滑动窗口实质是双指针）。都可以降低暴力解法的时间复杂度。

学习链接

代码随想录