剑指 Offer II 057. 值和下标之差都在给定的范围内（中等 数组 桶排序 滑动窗口 TreeSet）

剑指 Offer II 057. 值和下标之差都在给定的范围内

请实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内没有其他安排，则可以存储这个新的日程安排。

MyCalendar 有一个 book(int start, int end)方法。它意味着在 start 到 end 时间内增加一个日程安排，注意，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end。

当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生重复预订。

每次调用 MyCalendar.book方法时，如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true。否则，返回 false 并且不要将该日程安排添加到日历中。

请按照以下步骤调用 MyCalendar 类: MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)

示例:

输入:
[“MyCalendar”,“book”,“book”,“book”]
[[],[10,20],[15,25],[20,30]]
输出: [null,true,false,true]
解释:
MyCalendar myCalendar = new MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(15, 25); // returns false ，第二个日程安排不能添加到日历中，因为时间 15 已经被第一个日程安排预定了
MyCalendar.book(20, 30); // returns true ，第三个日程安排可以添加到日历中，因为第一个日程安排并不包含时间 20

提示：

每个测试用例，调用 MyCalendar.book 函数最多不超过 1000次。
0 <= start < end <= 109

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fi9suh
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

方法一：使用 TreeSet
时间复杂度O(nlogk)
利用TreeSet的特性，遍历数组，在TreeSet中添加大小为k的滑动窗口中的数字，每遍历一个数，利用ceiling方法和floor方法寻找满足条件的数字，找到了就返回true，没找到就继续遍历。
需要注意TreeSet的参数要使用Long类型，因为基本类型int不能是null。
方法二：哈希表桶排序思路
时间复杂度O(n)
利用桶排序的思想，由于要求的两数字的大小之差是小于等于t，可以准备k个桶，每个桶的大小是t + 1，如0号桶存储大小为0~t的数字，1号桶存储t + 1到2t + 1的数字，桶的编号可以用num / (t + 1)得来，遍历的过程中如果遍历到的数字所属于的桶（编号id）已经存在了，那么说明存在两个值的差小于等于 t，如果id桶不存在，则判断相邻的id - 1的桶和id + 1的桶的数是否与当前数的差小于等于t。
明确了思路后，还需要注意的是：1、数字可能是负的，对于负数来说，数字-t - 1到-1应该放在-1号桶中，-2t-2到-t-2应该放在-2号桶中，负数桶的编号可以用(num + 1)/ (t + 1) - 1得来；2、数字可能会越界，如果t = 2^31 - 1，t + 1会越界，同理num + 1也可能越界，所以所有数字的类型定义应该定义成long类型。

题解（Java）

方法一：使用 TreeSet

class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        TreeSet<Long> set = new TreeSet<>();
        for (int i = 0; i < nums.length; i++) {
            Long lower = set.floor((long)nums[i]);
            if (lower != null && (long)nums[i] - lower <= t) {
                return true;
            }
            Long higher = set.ceiling((long)nums[i]);
            if (higher != null && higher - (long)nums[i] <= t) {
                return true;
            }
            set.add((long)nums[i]);
            if (i >= k) {
                set.remove((long)nums[i - k]);
            }
        }
        return false;
    }
}

方法二：哈希表桶排序思路

class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        Map<Long, Long> map = new HashMap<>();
        Long size = (long)t + 1;
        for (int i = 0; i < nums.length; i++) {
            Long num = (long)nums[i];
            Long id = getId(num, size);
            if (map.containsKey(id) ||
            (map.containsKey(id - 1) && num - map.get(id - 1) <= t) ||
            (map.containsKey(id + 1) && map.get(id + 1) - num <= t)) {
                return true;
            }
            map.put(id, num);
            if (i >= k) {
                map.remove(getId((long)nums[i - k], size));
            }
        }
        return false;
    }

    private Long getId(Long num, Long size) {
        return num >= 0 ? num / size : (num + 1) / size - 1;
    }
}