算法-数组-有序数组的平方+长度最小的子数组

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

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

对于这道题目，我首先想到的就是将所有的数据平方以后再将这个数组排序，代码如下所示：

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i = 0;i< nums.length;i++){
            nums[i] = nums[i] * nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }
}

数组其实是有序的， 只不过负数平方之后可能成为最大数了。那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。此时可以考虑双指针法了，i指向起始位置，j指向终止位置。定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。
如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j];
如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i];

class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                //如果左边的数据平方大于右边的数据平方，那么就将左边的数据的平方加入到新的数组中
                result[index--] = nums[left] * nums[left];
                ++left;  
            } else {
                //如果右边的数据平方大于左边的数据平方，那么就将右边的数据的平方加入到新的数组中
                result[index--] = nums[right] * nums[right];
                --right;  
            }
        }
        return result;
    }
}

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

示例：

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

看到这个题，我们首先想到的就是使用循环来遍历，然后来求每一个符合条件的字串，然后返回最短的那一个子串就可以了代码如下：

//首先我先介绍常规的思路：
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //首先定义一个int类型的最大值，如果有比这个数小的话，那么就将小的数据赋值给count
        int count = Integer.MAX_VALUE;
        //采用双指针的方法，定义两个指针，在最初的时候都是指向这个数组的第一个元素的位置
        int left = 0;
        int right = 0;
        //while循环的条件是当这两个指针都没有超过这个数组的长度的时候
        while(left < nums.length && right < nums.length){
            int sum = 0;//定义一个sum，用来计算这个值，只有当计算的总和大于target的时候就比较一个这长度
            while(right < nums.length){
                sum += nums[right];
                if(sum >= target){
                    count = count < (right - left + 1) ? count: (right - left + 1);
                    //当达到了这个长度的时候就可以停止这个while循环，有了这个break可以减少很多时间
                    break;
                }
                //当没有达到这个长度的时候，就将right继续向后移动，知道达到这个的长度
                right++;
            }
            //这里是非常重要的，当一次遍历结束以后，这个左边的指针就必须向后移动一格，并且这个右边的指针就需要回到左指针的位置
            left++;
            right = left;
        }
        //由于在最后的时候，题目要求的如果达不到要求的话，那么就需要返回0，因此这里在返回的时候就需要做一个判断
        return count == Integer.MAX_VALUE ? 0 : count;
    }
}

接下来就开始介绍数组操作中另一个重要的方法：滑动窗口。所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

窗口就是 满足其和 ≥ s 的长度最小的连续子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，窗口的起始位置设置为数组的起始位置就可以了。

class Solution {
    public static int minSubArrayLen(int target, int[] nums) {
        int minLen = Integer.MAX_VALUE;
        int sum = 0;
        int i = 0;
        for(int j = 0;j < nums.length;j++){
            sum += nums[j];
            while(sum >= target){
                minLen = minLen <= (j - i + 1) ? minLen : (j - i + 1);
                sum -= nums[i++];
            }
        }
        return minLen == Integer.MAX_VALUE ? 0 : minLen;
    }
}

以上是我根据代码随想录学习算法的思考，如有错误或者侵权的地方，请联系我改正或者删除。欢迎大家和我一起探讨关于java和算法的知识。