【leetcode】1438. 绝对差不超过限制的最长连续子数组 双指针 + 有序数据结构

给你一个整数数组 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. 

本题的思路在于动态维护一个子数组的最大、最小值，并且保证新遍历到的每一个数字都满足绝对值得条件。

动态维护一个子数组的最大、最小值可以使用 Java 中的 TreeMap，它提供了 firstKey()、lastKey()的方式可以取出最大最小值，他的底层是红黑树，一种稳定的维护有序数组的树。

用双指针的方式去不断缩放满足绝对差不超过限制的最长连续子数组，并用 firstKey()、lastKey()拿出最大最小值进行比较。满足的 右指针 ++，不满足的让左指针不断右移。

    public int longestSubarray(int[] nums, int limit) {
        TreeMap cntMap = new TreeMap<>();
        int ans = 1;
        int l = 0;
        int r = 1;
        cntMap.put(nums[0], 1);
        while(r < nums.length) {
            int min = cntMap.firstKey();
            int max = cntMap.lastKey();
            if(Math.abs(nums[r] - min) <= limit && Math.abs(nums[r] - max) <= limit) {
                cntMap.put(nums[r], cntMap.getOrDefault(nums[r], 0) + 1);
                r++;
            } else {
                while(l < r && (Math.abs(nums[r] - min) > limit || Math.abs(nums[r] - max) > limit)) {
                    int cnt = cntMap.get(nums[l]);
                    cnt--;
                    if(cnt == 0) {
                        cntMap.remove(nums[l]);
                    } else {
                        cntMap.put(nums[l], cnt);
                    }
                    l++;
                    if(l < r) {
                        min = cntMap.firstKey();
                        max = cntMap.lastKey();
                    }
                }
                cntMap.put(nums[r], cntMap.getOrDefault(nums[r], 0) + 1);
                r++;
            }
            ans = Math.max(ans, r - l + 1);
        }
        return ans;
    }