【一天三道算法题】代码随想录——Day4

第四天！

一. 有序数组的平方

题目链接：力扣

思路：

        0. 暴力，对，这道题可以暴力，直接平方然后sort排序扔回去，是可以过的。

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

        1.双指针法

                因为数组是有序的， 只不过负数平方之后可能成为最大数。那么数组平方的最大值就在

        数组的两端，不是最左边就是最右边，不可能是中间。

                所以就可以考虑双指针法了，left 指向起始位置，right 指向终止位置。

                定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

        - 如果arr[left] * arr[left] < arr[right] * arr[right] 

                那么result[i--] = arr[right] * arr[right];

        - 如果arr[left] * arr[left] >= arr[right] * arr[right]  

                那么result[i--] = arr[left] * arr[left];

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length-1;

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

二. 长度最小的子数组

题目链接：力扣

思路：

        滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

        可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

代码：

class Solution {
    //滑动窗口
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for(int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while(sum >= target) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

为什么时间复杂度是O(n)呢？

        主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n ，忽略常数项，也就是O(n)。

三. 水果成篮

题目链接：力扣

思路：

        可以使用滑动窗口解决本题，left 和 right 分别表示满足要求的窗口的左右边界，同时我们使用哈希表存储这个窗口内的数以及出现的次数。

        每次将 right 移动一个位置，并将 fruits[right] 加入哈希表。如果此时哈希表不满足要求（即哈希表中出现超过两个键值对），那么我们需要不断移动 left ，并将 fruits[left] 从哈希表中移除，直到哈希表满足为止。

        需要注意的是，将 fruits[left] 从哈希表中移除后，如果 fruits[left] 在哈希表中的出现次数减少为 0，需要将对应的键值对从哈希表中移除。

代码：

class Solution {
    public int totalFruit(int[] fruits) {
        int n = fruits.length;
        Map<Integer, Integer> lanZi = new HashMap<Integer, Integer>();

        int left = 0, result = 0;

        for(int right = 0; right < n; right++){
            lanZi.put(fruits[right], lanZi.getOrDefault(fruits[right], 0) + 1);
            while (lanZi.size() > 2){
                lanZi.put(fruits[left], lanZi.get(fruits[left]) - 1);
                if(lanZi.get(fruits[left]) == 0){
                    lanZi.remove(fruits[left]);
                }
                left++;
            }
            result = Math.max(result, right - left + 1);
        }
        return result;
    }
}