leecode 解题总结：57. Insert Interval

#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
/*
问题:
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].

分析:
如果能够合并仍然需要满足: newInterval.start在一个区间interval1中，newInteval.end在另一个区间interval2中
必须满足
interval1.start <= newInterval.start <= interval1.end
interval2.start <= newInterval.end <= interval2.end
如果发现interval1和interval2是同一个，或者无法找到这样的interval1和interval2，说明无需合并

输入：
2(原始区间个数) 2(新区间起始位置) 5(新区间结束位置)
1 3
6 9

5 4 9
1 2
3 5
6 7
8 10
12 16

1 2 7
1 5
输出:
1 5,6 9
1 2,3 10,12 16
1 7

关键:
1 另一种解法:将当前插入的区间插入在待插入位置，然后合并，时间复杂度为O(n)
如果没有找到插入位置需要判断是在头部还是尾部插入
		//如果没有找到，需要在末尾插入或者首部插入
		if(!isFind)
		{
			//如果新区间的首部比第一个区间首部要小
			if(newInterval.start <= intervals.at(0).start)
			{
				intervals.insert(intervals.begin() , newInterval);
			}
			//如果新区间的首部比最后一个区间首部要大
			else if(newInterval.start >= intervals.at(size - 1).start)
			{
				intervals.push_back(newInterval);
			}
		}
*/


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>& intervals, Interval newInterval) {
		vector<Interval> result;
        if(intervals.empty())
		{
			result.push_back(newInterval);
			return result;
		}
		int size = intervals.size();
		//这里可能没有插入
		bool isFind = false;
		for(int i = 1 ; i < size ; i++)
		{
			//寻找起始位置，当前区间的起始位置 <= 新区间起始位置 < 下一个区间起始位置
			if(intervals.at(i-1).start <= newInterval.start && newInterval.start < intervals.at(i).start)
			{
				intervals.insert(intervals.begin() + i , newInterval);
				isFind = true;
				break;
			}
		}
		//如果没有找到，需要在末尾插入或者首部插入
		if(!isFind)
		{
			//如果新区间的首部比第一个区间首部要小
			if(newInterval.start <= intervals.at(0).start)
			{
				intervals.insert(intervals.begin() , newInterval);
			}
			//如果新区间的首部比最后一个区间首部要大
			else if(newInterval.start >= intervals.at(size - 1).start)
			{
				intervals.push_back(newInterval);
			}
		}
		//接下来生成结果
		size = intervals.size();
		int start = intervals.at(0).start;
		int end = intervals.at(0).end;
		for(int i = 1 ; i < size ; i++)
		{
			//发生重叠
			if(intervals.at(i).start <= end)
			{
				end = max(end , intervals.at(i).end);
			}
			else
			{
				Interval nInterval(start , end);
				result.push_back(nInterval);
				start = intervals.at(i).start;
				end = intervals.at(i).end;
			}
		}
		Interval nInterval(start , end);
		result.push_back(nInterval);
		return result;
    }
};

void print(vector<Interval>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << result.at(i).start << " "<< result.at(i).end << "," ;
	}
	cout << endl;
}

void process()
{
	 vector<Interval> intervals;
	 int num;
	 Solution solution;
	 vector<Interval> result;
	 int start;
	 int end;
	 Interval interval;
	 while(cin >> num )
	 {
		 cin >> start >> end;
		 interval.start = start;
		 interval.end = end;
		 intervals.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> start >> end;
			 Interval interval(start , end);
			 intervals.push_back(interval);
		 }
		 result = solution.insert(intervals , interval);
		 print(result);
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}