LeetCode-Data Stream as Disjoint Intervals

Given a data stream input of non-negative integers a₁, a₂, ..., a_n, ..., summarize the numbers seen so far as a list of disjoint intervals.

For example, suppose the integers from the data stream are 1, 3, 7, 2, 6, ..., then the summary will be:

[1, 1]
[1, 1], [3, 3]
[1, 1], [3, 3], [7, 7]
[1, 3], [7, 7]
[1, 3], [6, 7]

Follow up:
What if there are lots of merges and the number of disjoint intervals are small compared to the data stream's size?

Credits:
Special thanks to @yunhong for adding this problem and creating most of the test cases.

Solution 1:

 /**
  * Definition for an interval.
  * public class Interval {
  *     int start;
  *     int end;
  *     Interval() { start = 0; end = 0; }
  *     Interval(int s, int e) { start = s; end = e; }
  * }
  */
 public class SummaryRanges {

    /** Initialize your data structure here. */
         public SummaryRanges() {
             startMap = new HashMap<Integer, Interval>();
             endMap = new HashMap<Integer, Interval>();
             addedNum = new HashSet<Integer>();
         }

         public void addNum(int val) {
             if (addedNum.contains(val)) return;

             Interval pre = null, after = null;
             if (endMap.containsKey(val - 1))
                 pre = endMap.get(val - 1);
             if (startMap.containsKey(val + 1))
                 after = startMap.get(val + 1);

             if (pre != null && after != null) {
                 endMap.remove(after.end);
                 startMap.remove(after.start);
                 endMap.remove(pre.end);
                 pre.end = after.end;
                 endMap.put(pre.end, pre);
             } else if (pre != null) {
                 endMap.remove(pre.end);
                 pre.end = val;
                 endMap.put(val, pre);
             } else if (after != null) {
                 startMap.remove(after.start);
                 after.start = val;
                 startMap.put(val, after);
             } else {
                 Interval single = new Interval(val, val);
                 endMap.put(val, single);
                 startMap.put(val, single);
             }

             addedNum.add(val);
         }

         public List<Interval> getIntervals() {
             List<Interval> intervalList = new ArrayList<Interval>(endMap.values());
             Collections.sort(intervalList, new Comparator<Interval>() {
                 public int compare(Interval v1, Interval v2) {
                     return v1.start - v2.start;
                 }
             });
             return intervalList;
         }

         HashMap<Integer, Interval> startMap;
         HashMap<Integer, Interval> endMap;
         HashSet<Integer> addedNum;
 }

 /**
  * Your SummaryRanges object will be instantiated and called as such:
  * SummaryRanges obj = new SummaryRanges();
  * obj.addNum(val);
  * List<Interval> param_2 = obj.getIntervals();
  */

This solution introduces many redundant: To find the "pre", we only need to find the interval with the largest start that is less than val. In short, we only need to compare Interval.start

Solution 2:

 /**
  * Definition for an interval.
  * public class Interval {
  *     int start;
  *     int end;
  *     Interval() { start = 0; end = 0; }
  *     Interval(int s, int e) { start = s; end = e; }
  * }
  */
 public class SummaryRanges {

     /** Initialize your data structure here. */
     public SummaryRanges() {
         itvlSet = new TreeSet<Interval>(new Comparator<Interval>(){
             public int compare(Interval v1, Interval v2){
                 return v1.start-v2.start;
             }
         });

     }

     public void addNum(int val) {
         Interval itvl = new Interval(val,val);
         Interval pre = itvlSet.floor(itvl);
         Interval after = itvlSet.ceiling(itvl);

         if ( (pre!=null && pre.end >= val) || (after!=null && after.start <=val)) return;

         if (pre!=null && pre.end==val-1){
             itvlSet.remove(pre);
             itvl.start = pre.start;
         }
         if (after!=null && after.start==val+1){
             itvlSet.remove(after);
             itvl.end = after.end;
         }
         itvlSet.add(itvl);
     }

     public List<Interval> getIntervals() {
         return new ArrayList<Interval>(itvlSet);

     }

     TreeSet<Interval> itvlSet;
 }

 /**
  * Your SummaryRanges object will be instantiated and called as such:
  * SummaryRanges obj = new SummaryRanges();
  * obj.addNum(val);
  * List<Interval> param_2 = obj.getIntervals();
  */