1438. 绝对差不超过限制的最长连续子数组（优先队列和滑动窗口 或 TreeMap方法）

绝对差不超过限制的最长连续子数组

给你一个整数数组 nums ，和一个表示限制的整数 limit，请你返回最长连续子数组的长度，该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。如果不存在满足条件的子数组，则返回 0 。

示例 1：
输入：nums = [8,2,4,7], limit = 4
输出：2
解释：所有子数组如下：
[8] 最大绝对差 |8-8| = 0 <= 4.
[8,2] 最大绝对差 |8-2| = 6 > 4.
[8,2,4] 最大绝对差 |8-2| = 6 > 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.
[2] 最大绝对差 |2-2| = 0 <= 4.
[2,4] 最大绝对差 |2-4| = 2 <= 4.
[2,4,7] 最大绝对差 |2-7| = 5 > 4.
[4] 最大绝对差 |4-4| = 0 <= 4.
[4,7] 最大绝对差 |4-7| = 3 <= 4.
[7] 最大绝对差 |7-7| = 0 <= 4.
因此，满足题意的最长子数组的长度为 2 。

示例 2：
输入：nums = [10,1,2,4,7,2], limit = 5
输出：4
解释：满足题意的最长子数组是 [2,4,7,2]，其最大绝对差 |2-7| = 5 <= 5 。

示例 3：
输入：nums = [4,2,2,2,4,4,2,2], limit = 0
输出：3

---

解题思路

滑动窗口(双指针)：left 指针和 right 指针，开始时均指向 nums 数组的开头。并利用两个优先队列来分别存放当前窗口中所有元素值，一个是小根堆，另一个是大根堆(每次加入的是 right 指针指向的元素值)。然后判断两个优先队列中队首元素之差的绝对值是否小于等于 limit 值：

• 若不满足条件：则此时需要将窗口整体右移一位，要将当前 left 指针指向的元素在两个优先队列中删除，然后再将 left 指针右移一位，此时也需要将 right 指针向右移动一位，因为 right 指针移动之前指向的元素值已经添加到两个优先队列中了，向右移动一位再添加新的元素。
• 若满足条件：则需要判断此时窗口的大小和之前已经保存的连续子数组的长度谁更大，留下更大的那个值。然后将 right 指针向右移动一位，将窗口的长度扩大继续进行判断。

两个优先队列中存放的都是符合条件的连续的元素，不符合条件的元素会及时的从队列中删除。 当 right 指针指到 nums 数组末尾时，直接结束返回符合条件的最长子数组的长度。

---

代码

class Solution {

    public int longestSubarray(int[] nums, int limit) {

        //小根堆
        PriorityQueue<Integer> windowMin = new PriorityQueue<>();
        //大根堆
        PriorityQueue<Integer> windowMax = new PriorityQueue<>(Comparator.reverseOrder());

        int n = nums.length;
        int left = 0, right = 0;
        int maxLength = 0;
        for (right=0;right<n;right++) {

            windowMin.offer(nums[right]);
            windowMax.offer(nums[right]);

            //若当前子数组不满足条件，则后面的都不需要再看了，直接令left指针右移一位
            if (windowMax.peek() - windowMin.peek() > limit) {

                windowMax.remove((Integer) nums[left]);
                windowMin.remove((Integer) nums[left]);
                left++;
            } else {

                maxLength = Math.max(maxLength, right - left + 1);
            }
        }
        return maxLength;
    }
}

时间复杂度：n 个元素遍历一遍，若运气很差，每次都需要入堆调整，调整时间复杂度为堆的高度，即log(k)，故整体时间复杂度为O(n*log(k))。
空间复杂度：定义了两个优先队列，长度为 n，则复杂度为O(n + n) = O(2n) = O(n)。(常数不考虑在内)

---

TreeMap方法

用 java 中的 TreeMap(平衡二叉搜索树)，当插入新元素时，会自动调整树的高度以及各个元素的位置：即根节点均大于它的左子树，均小于它的右子树。这样检索速度快，并且允许出现重复值。能够迅速的得到树中的最大值和最小值。

TreeMap 中存放的是滑动窗口中的元素，以及元素的出现次数。其中 getOrDefault 方法是：若 map 中含有指定的 key，就返回该 key 对应的 value值，否则使用该方法的第二个参数作为默认值返回。

(1) lastKey() 和 firstKey() 方法分别用来返回树中的最后一个值(最大值)和第一个值(最小值)。若它们的差大于 limit，则此时需要向右移动窗口，要将 left 指针所指向的元素再重新添加一遍，并且它的出现次数的值 - 1；若它们的差小于等于 limit，则直接跳到第 (3) 步即可。

(2) 然后，判断当前 left 指针指向的元素的出现次数是否为 0：若为 0，则直接删除该元素并令 left 指针向右移动一位；若不为 0，说明此时窗口中仍有该元素，则直接令 left 指针向右移动一位。

(3) 最后，比较当前窗口大小和之前保存的最大的窗口大小，保留更大的，然后将 right 指针向右移动一位。

class Solution {

    public int longestSubarray(int[] nums, int limit) {
		
        TreeMap<Integer, Integer> m = new TreeMap<>();
        int left = 0, right = 0;
        int res = 0;
        while (right < nums.length) {
				
			//因为添加，所以最后要 + 1
            m.put(nums[right], m.getOrDefault(nums[right], 0) + 1);
            while (m.lastKey() - m.firstKey() > limit) {
						
                m.put(nums[left], m.get(nums[left]) - 1);
                if (m.get(nums[left]) == 0) {
								
                    m.remove(nums[left]);
                }
                left ++;
            }
            res = Math.max(res, right - left + 1);
            right ++;
        }
        return res;
    }
}

TreeMap 方法适合当题目中出现需要利用最小值和最大值来进行操作的情况。