352. 将数据流变为多个不相交区间

前言

C++是一种计算机高级程序设计语言，由C语言扩展升级而产生 ，最早于1979年由本贾尼·斯特劳斯特卢普在AT&T贝尔工作室研发。
C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计。
C++拥有计算机运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力。

Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 。

Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆 于1990 年代初设计，作为一门叫做ABC语言的替代品。Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。
Python解释器易于扩展，可以使用C语言或C++（或者其他可以通过C调用的语言）扩展新的功能和数据类型。Python 也可用于可定制化软件中的扩展程序语言。Python丰富的标准库，提供了适用于各个主要系统平台的源码或机器码。
2021年10月，语言流行指数的编译器Tiobe将Python加冕为最受欢迎的编程语言，20年来首次将其置于Java、C和JavaScript之上。

描述

给你一个由非负整数 a1, a2, ..., an 组成的数据流输入，请你将到目前为止看到的数字总结为不相交的区间列表。

实现 SummaryRanges 类：

    SummaryRanges() 使用一个空数据流初始化对象。
    void addNum(int val) 向数据流中加入整数 val 。
    int[][] getIntervals() 以不相交区间 [starti, endi] 的列表形式返回对数据流中整数的总结。

示例：

输入：
["SummaryRanges", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals"]
[[], [1], [], [3], [], [7], [], [2], [], [6], []]
输出：
[null, null, [[1, 1]], null, [[1, 1], [3, 3]], null, [[1, 1], [3, 3], [7, 7]], null, [[1, 3], [7, 7]], null, [[1, 3], [6, 7]]]

解释：
SummaryRanges summaryRanges = new SummaryRanges();
summaryRanges.addNum(1);      // arr = [1]
summaryRanges.getIntervals(); // 返回 [[1, 1]]
summaryRanges.addNum(3);      // arr = [1, 3]
summaryRanges.getIntervals(); // 返回 [[1, 1], [3, 3]]
summaryRanges.addNum(7);      // arr = [1, 3, 7]
summaryRanges.getIntervals(); // 返回 [[1, 1], [3, 3], [7, 7]]
summaryRanges.addNum(2);      // arr = [1, 2, 3, 7]
summaryRanges.getIntervals(); // 返回 [[1, 3], [7, 7]]
summaryRanges.addNum(6);      // arr = [1, 2, 3, 6, 7]
summaryRanges.getIntervals(); // 返回 [[1, 3], [6, 7]]

方法一：使用有序映射维护区间

思路与算法

假设我们使用某一数据结构维护这些不相交的区间，在设计具体的数据结构之前，我们需要先明确 void addNum(int val)\texttt{void addNum(int val)}void addNum(int val) 这一操作会使得当前的区间集合发生何种变化：

    情况一：如果存在一个区间 [l,r][l, r][l,r]，它完全包含 val\textit{val}val，即 l≤val≤rl \leq \textit{val} \leq rl≤val≤r，那么在加入 val\textit{val}val 之后，区间集合不会有任何变化；

    情况二：如果存在一个区间 [l,r][l, r][l,r]，它的右边界 rrr「紧贴着」val\textit{val}val，即 r+1=valr + 1 = \textit{val}r+1=val，那么在加入 val\textit{val}val 之后，该区间会从 [l,r][l, r][l,r] 变为 [l,r+1][l, r+1][l,r+1]；

    情况三：如果存在一个区间 [l,r][l, r][l,r]，它的左边界 lll「紧贴着」val\textit{val}val，即 l−1=vall - 1 = \textit{val}l−1=val，那么在加入 val\textit{val}val 之后，该区间会从 [l,r][l, r][l,r] 变为 [l−1,r][l - 1, r][l−1,r]；

    情况四：如果情况二和情况三同时满足，即存在一个区间 [l0,r0][l_0, r_0][l0​,r0​] 满足 r0+1=valr_0+1 = \textit{val}r0​+1=val，并且存在一个区间 [l1,r1][l_1, r_1][l1​,r1​] 满足 l1−1=vall_1-1 = \textit{val}l1​−1=val，那么在加入 val\textit{val}val 之后，这两个区间会合并成一个大区间 [l0,r1][l_0, r_1][l0​,r1​]；

    情况五：在上述四种情况均不满足的情况下，val\textit{val}val 会单独形成一个新的区间 [val,val][\textit{val}, \textit{val}][val,val]。

根据上面的五种情况，我们需要找到离 val\textit{val}val 最近的两个区间。用严谨的语言可以表述为：

    对于给定的 val\textit{val}val，我们需要找到区间 [l0,r0][l_0, r_0][l0​,r0​]，使得 l0l_0l0​ 是最大的满足 l0≤vall_0 \leq \textit{val}l0​≤val 的区间。同时，我们需要找到区间 [l1,r1][l_1, r_1][l1​,r1​]，使得 l1l_1l1​ 是最小的满足 l1>vall_1 > \textit{val}l1​>val 的区间。

如果我们的数据结构能够快速找到这两个区间，那么上面的五种情况分别对应为：

    情况一：l0≤val≤l1l_0 \leq \textit{val} \leq l_1l0​≤val≤l1​；
    情况二：r0+1=valr_0 + 1 = \textit{val}r0​+1=val；
    情况三：l1−1=vall_1 - 1 = \textit{val}l1​−1=val；
    情况四：r0+1=valr_0 + 1 = \textit{val}r0​+1=val 并且 l1−1=vall_1 - 1 = \textit{val}l1​−1=val；
    情况五：上述情况均不满足。

一种可以找到「最近」区间的数据结构是有序映射。有序映射中的键和值分别表示区间的左边界 lll 和右边界 rrr。由于有序映射支持查询「最大的比某个元素小的键」以及「最小的比某个元素大的键」这两个操作，因此我们可以快速地定位区间 [l0,r0][l_0, r_0][l0​,r0​] 和 [l1,r1][l_1, r_1][l1​,r1​]。

除此之外，对于 int[][] getIntervals()\texttt{int[][] getIntervals()}int[][] getIntervals() 操作，我们只需要对有序映射进行遍历，将所有的键值对返回即可。

细节

在实际的代码编写中，需要注意 [l0,r0][l_0, r_0][l0​,r0​] 或 [l1,r1][l_1, r_1][l1​,r1​] 不存在的情况。

代码

class SummaryRanges {
    TreeMap<Integer, Integer> intervals;

    public SummaryRanges() {
        intervals = new TreeMap<Integer, Integer>();
    }
    
    public void addNum(int val) {
        // 找到 l1 最小的且满足 l1 > val 的区间 interval1 = [l1, r1]
        // 如果不存在这样的区间，interval1 为尾迭代器
        Map.Entry<Integer, Integer> interval1 = intervals.ceilingEntry(val + 1);
        // 找到 l0 最大的且满足 l0 <= val 的区间 interval0 = [l0, r0]
        // 在有序集合中，interval0 就是 interval1 的前一个区间
        // 如果不存在这样的区间，interval0 为尾迭代器
        Map.Entry<Integer, Integer> interval0 = intervals.floorEntry(val);

        if (interval0 != null && interval0.getKey() <= val && val <= interval0.getValue()) {
            // 情况一
            return;
        } else {
            boolean leftAside = interval0 != null && interval0.getValue() + 1 == val;
            boolean rightAside = interval1 != null && interval1.getKey() - 1 == val;
            if (leftAside && rightAside) {
                // 情况四
                int left = interval0.getKey(), right = interval1.getValue();
                intervals.remove(interval0.getKey());
                intervals.remove(interval1.getKey());
                intervals.put(left, right);
            } else if (leftAside) {
                // 情况二
                intervals.put(interval0.getKey(), interval0.getValue() + 1);