228. Summary Ranges && 163 Missing Ranges && 352. Data Stream as Disjoint Intervals

228. Summary Ranges

Given a sorted integer array without duplicates, return the summary of its ranges.

For example, given

[0,1,2,4,5,7]

, return

["0->2","4->5","7"].

Array

public class Solution {
public List<String> summaryRanges(int[] nums) {
List<String> list=new ArrayList();
if(nums.length==1){
list.add(Integer.toString(nums[0]));
return list;
}
for(int i=0;i<nums.length;i++){
int begin=nums[i];
//move i all the way to the end
while(i+1<nums.length && (nums[i+1]-nums[i])==1)
i++;

if(begin!=nums[i])
list.add(begin+"->"+nums[i]);
else
list.add(Integer.toString(begin));
}
return list;
}
}

163 Missing Ranges

Given a sorted integer array where the range of elements are [lower, upper] inclusive, return its missing ranges.

For example, given [0, 1, 3, 50, 75], lower = 0 and upper = 99, return ["2", "4->49", "51->74", "76->99"].

public List<String> findMissingRanges(int[] a, int lo, int hi) {
List<String> res = new ArrayList<String>();

// the next number we need to find
int next = lo;

for (int i = 0; i < a.length; i++) {
// not within the range yet
if (a[i] < next) continue;

// continue to find the next one
if (a[i] == next) {
next++;
continue;
}

// get the missing range string format
res.add(getRange(next, a[i] - 1));

// now we need to find the next number
next = a[i] + 1;
}

// do a final check
if (next <= hi) res.add(getRange(next, hi));

return res;
}

String getRange(int n1, int n2) {
return (n1 == n2) ? String.valueOf(n1) : String.format("%d->%d", n1, n2);
}

352. Data Stream as Disjoint Intervals

Given a data stream input of non-negative integers a1, a2, ..., an, ..., 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?

Binary Search Tree

/**
* 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 {

TreeMap<Integer, Interval> tree;

/** Initialize your data structure here. */
public SummaryRanges() {
//key is the start of the interval
tree = new TreeMap<>();
}

public void addNum(int val) {
if (tree.containsKey(val))
return;

Integer l = tree.lowerKey(val); // l -> [l, ?]
Interval lInterval = null;
if (l != null)
lInterval = tree.get(l);  //this indicates val >= l

Integer h = tree.higherKey(val); // h -> [h, ?]

if (lInterval != null && h != null &&
lInterval.end + 1 == val &&
h == val + 1) {
//merging two surrounding intervals
lInterval.end = tree.get(h).end;
tree.remove(h);
} else { //only has interval at one end
if (lInterval != null && lInterval.end + 1 >= val) {
//merge with left interval
lInterval.end = Math.max(lInterval.end, val);
} else if (h != null && h == val + 1) {
//update right interval
tree.put(val, new Interval(val, tree.get(h).end));
tree.remove(h);
} else {
tree.put(val, new Interval(val, val));
}
}
}

public List<Interval> getIntervals() {
return new ArrayList<>(tree.values());
}
}

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