Merge Intervals

/*

Merge Intervals

Given a collection of intervals, merge all overlapping intervals.
For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

*/
/**
 * 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:
   void findIndex(vector<Interval> intervals, int & startPrevIndex, int num){
       int size = intervals.size();
       if(num<intervals[startPrevIndex].start) return;
       while(startPrevIndex<size){
         if(intervals[startPrevIndex].start <= num && (startPrevIndex == (size-1) || num < intervals[startPrevIndex+1].start)){
            return;
         }
         startPrevIndex++;
       } 
    }
      void findEndIndex(vector<Interval> intervals, int & endPrevIndex, int num){
       int size = intervals.size();
       if(num<intervals[endPrevIndex].end) return;
       while(endPrevIndex<size){
         if(intervals[endPrevIndex].end <= num && (endPrevIndex == (size-1) || num < intervals[endPrevIndex+1].end)){
            return;
         }
         endPrevIndex++;
       } 
    }
    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(newInterval.start > newInterval.end) return intervals;
        int size = intervals.size();
        if(size==0){
          intervals.push_back(newInterval);
          return intervals;
        }
       
        int start = newInterval.start;
        int end = newInterval.end;
       
        if(end < intervals[0].start){
          intervals.insert(intervals.begin(), newInterval);
          return intervals;
        }
        if(end == intervals[0].start){
          intervals[0].start = newInterval.start;
          return intervals;
        }
        if(start > intervals[size-1].end){
          intervals.push_back(newInterval);
          return intervals;
        }
        if(start == intervals[size-1].end){
          intervals[size-1].end = newInterval.end;
    return intervals;
        }
       
        int startPrevIndex = 0;
        findIndex(intervals, startPrevIndex, start);
        int endPrevIndex = 0;
        findEndIndex(intervals, endPrevIndex, end);
       
        if(start<intervals[startPrevIndex].end && end<=intervals[startPrevIndex].end){
     if(startPrevIndex==0 && start<intervals[startPrevIndex].start){
      intervals[startPrevIndex].start = start;
     }
           return intervals;
        }
       
        int i;
       
        if(start<=intervals[startPrevIndex].end){
    
   if(startPrevIndex==0 && start<intervals[startPrevIndex].start){
      intervals[startPrevIndex].start = start;
     }
     i = startPrevIndex+1;
     if(endPrevIndex==size-1){
      while(i<=size-1){
     intervals.erase(intervals.begin()+startPrevIndex+1);
                 i++;
      }
      intervals[startPrevIndex].end = end;
      return intervals;
     }
           if(end<intervals[endPrevIndex+1].start){
             intervals[startPrevIndex].end = end;
             if(startPrevIndex==endPrevIndex) return intervals;
             while(i<=endPrevIndex){
               intervals.erase(intervals.begin()+startPrevIndex+1);
               i++;
             }
             return intervals;
           }
          
           if(end>=intervals[endPrevIndex+1].start){
             i = startPrevIndex+1;
             intervals[startPrevIndex].end = intervals[endPrevIndex+1].end;
             while(i<=(endPrevIndex+1)){
               intervals.erase(intervals.begin()+startPrevIndex+1);
               i++;
             }
             return intervals;
           }
        }
       
        if(start>intervals[startPrevIndex].end && end<intervals[startPrevIndex+1].start){
           intervals.insert(intervals.begin()+startPrevIndex+1, newInterval);
           return intervals;
        }
       
        if(start>intervals[startPrevIndex].end){
           intervals[startPrevIndex+1].start = start;
           i = startPrevIndex+2;
     if(endPrevIndex==size-1){
     while(i<=size-1){
      intervals.erase(intervals.begin()+startPrevIndex+2);
      i++;
     }
     intervals[startPrevIndex+1].end = end;
     return intervals;
     }
           if(end >= intervals[endPrevIndex+1].start){
             intervals[startPrevIndex+1].end = intervals[endPrevIndex+1].end;
             while(i<=(endPrevIndex+1)){
                intervals.erase(intervals.begin()+startPrevIndex+2);
                i++;
             }
             return intervals;
           }
          
           if(end < intervals[endPrevIndex+1].start){
             while(i<=(endPrevIndex)){
               intervals.erase(intervals.begin()+startPrevIndex+2);
               i++;
             }
             intervals[startPrevIndex+1].end = end;
             return intervals;
           }
        }     
    }
    vector<Interval> merge(vector<Interval> &intervals) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int size = intervals.size();
        if(size<=1) return intervals;
       
        vector<Interval> result;
        result.push_back(intervals[0]);
       
        int i;
        for(i=1; i<size; i++){
          result = insert(result, intervals[i]);
        }
       
        return result;
    }
};