leetcode: Merge Intervals

AC代码，重新申请一个vector，而不是in-place，就通过了

/**
 * 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> &res, Interval new_interval){
        auto iter = res.begin();
        while( iter != res.end()){
            if( new_interval.end < iter->start){
                res.insert( iter, new_interval);
                return res;
            }
            else if( iter->end < new_interval.start){
                ++iter;
                continue;
            }
            else{
                new_interval.start = min( iter->start, new_interval.start);
                new_interval.end = max( iter->end, new_interval.end);
                res.erase(iter);
            }
        }
        res.insert( res.end(), new_interval);
        return res;
    } 
    vector<Interval> merge(vector<Interval> &intervals) {
        vector< Interval> res;
        for( int i = 0; i < intervals.size(); ++i){
            insert( res, intervals[i]);
        }
        return res;
    }
};

TLE，哪里不够快呢。

还有这里可以不用自己写排序，只需要写个比较函数，然后调用库函数就可以了

/**
 * 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:
    static bool comp(Interval a, Interval b){  
        return a.start < b.start;  
    }  
    vector<Interval> merge(vector<Interval> &intervals) {
        if(intervals.size() <= 1)
            return intervals;
            
        sort( intervals.begin(), intervals.end(), comp); 
        int i = 0;
        while( i + 1 < intervals.size()){
            if( intervals[i].end < intervals[i+1].start){
                ++i;
            }
            else{
                intervals[i+1].start = min( intervals[i].start, intervals[i+1].start);
                intervals[i+1].end = max( intervals[i].end, intervals[i+1].end);
                intervals.erase( intervals.begin() + i);
            }
        }
        return intervals;
    }
    /*void swap( vector< Interval> &intervals, int i, int j){
        Interval tmp = intervals[i];
        intervals[i] = intervals[j];
        intervals[j] = tmp;
    }
    void quicksort( vector< Interval> &intervals, int l, int r){
        if( l < r){
            int pivot = intervals[0].start;
            swap( intervals, 0, r);
            int i = l, j = r - 1;
            while( true){
                while( intervals[i].start < pivot)
                    ++i;
                while( intervals[j].start > pivot)
                    --j;
                if( i < j)
                    swap( intervals, i, j);
                else
                    break;
            }
            swap( intervals, i, r);
            quicksort( intervals, l, i-1);
            quicksort( intervals, i+1, r);
        }
    }*/
};