代码随想录算法训练营day2——209长度最小的子数组+977有序数组平方

209长度最小的子数组

题目要求：

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

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

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

思路

第一想法

可以从头开始试，每遇到一个元素计算target-对应位置上的值，然后再去后面找减的结果，找的时候也是根据前面的规则，有种递归的感觉。

困难：

• 发现自己写不出来这种想法。所以看了答案的暴力双层for循环的写法，但是不理解的是break，一旦找到总和满足条件的就返回这个初始位置所对应的长度，但这是一种顺序的找法，没有跳着找啊，怎么能是所有情况呢？并且最后也超时了。
• 经过debug确实是顺着找的，没有做到跳着找。自我感觉有瑕疵这个方法。

正解：

滑动窗口——最核心是固定终止位置，如何移动起始位置。

• 先移动终止位置，找到一个满足条件的集合，再去移动起始位置去不断试探缩小这个集合，看它的总和是否还满足条件。
• 因为这个不断地去试探缩小，所以代码对于起始位置的移动需要用while而不是if
• 时间复杂度是2N，即O(n),因为所有元素都只操作了两次——进来出去

代码一：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //暴力尝试一下
        int len = nums.length;
        int ResultLength = Integer.MAX_VALUE;//注意这里的Java中的最大值写法(全大写)
        //定义子序列的长度和数值之和
        int sum = 0;
        int sublength = 0;
        for(int i = 0; i < len; i++){
            sum = 0;//每次进入大的for循环sum都要清零
            for(int j =i;j < len;j ++){
                sum += nums[j];//累加
                if(sum >= target){
                    //累加的结果满足条件了
                    sublength = j - i + 1;
                    ResultLength = ResultLength < sublength ? ResultLength : sublength;
                    break;//这里有些疑惑啊，直接break走了？比如示例2开始这样结果目前是4，但明显有更好的选择是3啊？
                }
            }
        }
        return ResultLength == Integer.MAX_VALUE ? 0 : ResultLength;
        //最后还超时了。。。。
    }
}

代码二：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //使用滑动窗口的思想，定住终止位置
        int start = 0;
        int sum =0;//这里就不用每次去清零sum了
        int result = Integer.MAX_VALUE;
        for(int end =0;end < nums.length; end ++){
            sum += nums[end];
            while(sum >= target){
                //进行起始位置的移动,记录当前满足条件的长度以及更新sum值
                result = Math.min(result,(end - start + 1));
                sum -= nums[start ++];
            }//每次出while循环，这个最终位置所对应的集合已经被起始位置压缩的最小了
        }//然后最终位置再向后移动去找
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

977有序数组的平方

题目要求：

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

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

思路

第一想法：

• 先用sqrt给每个元素都进行平方，然后再对无序数组排序不就好了。

困难：

自己经过考研只知道大概有9种排序手段，但是却一个都写不出来。

正解一：

正常平方之后进行排序，这里我使用了直接选择排序（也是数据结构复习里第一种排序，其中细节还是蛮多。）

时间复杂度根据不同排序方法各有差别，直接插入排序两层for循环为O(n平方)

代码一：

class Solution {
    public int[] sortedSquares(int[] nums) {
        //方法一：先将数组中元素全部平方，再对新数组进行排序
        //Java中平方函数为sqrt()
        int len = nums.length;
        for(int i = 0; i < len; i ++){
            nums[i] *= nums[i];//进行平方
        }
        //如何对一个无序数组进行排序排成非递减有序数组,ds里学过很多排序方法
        //直接插入排序，简单选择排序，快排等等。写个直接插入排序试一下。
        Insertsort(len , nums);
        return nums;
    }
    public void Insertsort(int n , int[] nums){
        int i,j;
        for( i = 1; i < n; i++){
            //在前面有序部分寻找插入位置
            int x = nums[i];
            for(j = i-1;j >= 0; j --){//在有序部分中逆序寻找插入的位置
                if(x < nums[j]){//这里必须是x注意别写成了nums[i]
                    nums[j+1] = nums[j];//将有序的部分向后移动挪位置
                }else{
                    break;
                }
            }
            nums[j+1] = x;//
        }
    }
}

正解二：

• 使用双指针法，因为平方后最大值一定在数组的两边，所以要排成非递减数组，可以设置一个新数组，指针指向其末尾；对于原数组设置头尾两个指针，移动前先比较两个值，大的放在新数组当中并且对应位置指针移动。

代码二：

class Solution {
    public int[] sortedSquares(int[] nums) {
        //方法二，双指针相向移动
        int len = nums.length;
        //创建一个新数组来保存最终结果
        int[] res = new int[len];
        //创建双指针
        int left = 0,right = len - 1;
        //创建新数组的尾指针
        int end = len - 1;
        //开始比较移动
        while(left <= right){//都是闭区间
            if(nums[left] * nums[left] < nums[right] * nums[right]){
                //如果左边的小，右边的数值就放到新数组当中，并且向左移动
                res[end --] = nums[right] * nums[right];
                right --;
            }else{
                res[end --] = nums[left] * nums[left];
                left ++;
            }
        }
        return res;//这个时间复杂度是N，空间复杂度也是N
    }
}

总结：

• 方法一是常规方法，语言自带的库函数能够直接排序，但是如果让我自己写一些排序的话，比如这里的直接插入，快速排序还是不能够信手捏来，所以平时对于这些排序的学习还要加强。
• 方法二是规律性方法，得先看出最大值一定在两边出现，然后利用双指针去不断逼近比较，但是有可能去想为什么里面的值能保证不会出现一个较大值，因为题干条件是原始数组是非递减的。