leetcode20: Insert Interval

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].

Example 2:
Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].

This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].

java version. can not pass large test case.

/**
 * 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; }
 * }
 */
 import java.util.ListIterator;
 
public class Solution {
    public ArrayList<Interval> insert(ArrayList<Interval> intervals, Interval newInterval) {
        // Start typing your Java solution below
        // DO NOT write main() function
        //ArrayList<Interval> res = new ArrayList<Inteval>();
        int sz = intervals.size();
        
        int low = newInterval.start;
        int high = newInterval.end;
        
        ListIterator<Interval> iter = intervals.listIterator();
        
        while(iter.hasNext() ) {
            Interval it =  iter.next();
            
            if(high<it.start) {
                iter.previous();
                iter.add( new Interval(low, high) );
                return intervals;
            }
            
            
            if(low>it.end) {
                continue;
            } else {
                low = Math.min(low, it.start);
                high = Math.max(high, it.end);
                iter.remove();
            }            
        }
        
        intervals.add(new Interval(low, high) );
        return intervals;
    }
}

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    vector<Interval> insert(vector<Interval> &ints, Interval newInterval) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<Interval> intervals( ints);
                
        int low = newInterval.start;
        int high = newInterval.end;
        
        bool delFlag = false;
        
        for(int i=0; i<intervals.size(); i++) {
            if( intervals[i].start <= low && ( i==intervals.size()-1 || intervals[i+1].start > low ) {
                if( intervals[i].end >= low) {
                    newInterval.start = intervals[i].start;
                    intervals.erase( intervals.begin() + i );
                } 
                delFlag = true;        
            }
            
            if( delFlag) {
                    intervals.erase( intervals.begin() + i);
            }
            
            if( intervals[i].end >= high ) {
                if( intervals[i].start <= high) {
                    newInterval.end = intervals[i].end;
                    intervals.erase( intervals.begin() + i);
                }
                delFlag = false;
                
                intervals.insert( newInterval, i-1);
            }
        }

        return intervals;
    }
};

peking2's treemap solution.

class Solution1
{
    TreeMap<Integer, Integer> tm = new TreeMap<Integer, Integer>();

    void insert(Interval interval)
    {
        Integer prev = tm.floorKey(interval.start);
        Integer next = tm.ceilingKey(interval.start);

        if (prev != null && tm.get(prev) >= interval.start || next != null
                && interval.end >= next)
        {
            int start = -1;

            if (prev != null && tm.get(prev) >= interval.start)
            {
                tm.put(prev, Math.max(tm.get(prev), interval.end));
                start = prev;
            }
            else
            {
                int s = interval.start;
                int e = Math.max(interval.end, tm.get(next));
                tm.remove(next);
                tm.put(s, e);
                start = s;
            }

            while (tm.higherKey(start) != null
                    && tm.get(start) >= tm.higherKey(start))
            {
                tm.put(start, Math.max(tm.get(start), tm.higherEntry(start)
                        .getValue()));
                tm.remove(tm.higherKey(start));
            }
        }
        else
            tm.put(interval.start, interval.end);
    }

2nd c++ try:

class Solution {
public:
    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
    //Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].
        //check input;
        int sz = intervals.size();
        vector<Interval> res;
        
        for(int i=0; i<sz; i++) {
            if(intervals[i].end < newInterval.start) {
                res.push_back( intervals[i]);
            } else if( intervals[i].start > newInterval.end) {
                res.push_back( newInterval);
                res.insert(res.end(), intervals.begin()+i, intervals.end() );
                return res;
            } else {
                newInterval.start = min(newInterval.start, intervals[i].start);
                newInterval.end = max(newInterval.end, intervals[i].end);
            }
        }
        res.push_back(newInterval); 
        return res;
    }