merge-intervals

packagecom.ytx.array;

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.Comparator;

/** 题目：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].

 *

 *@authoryuantian xin

 * 

 *  给一个包含若干区间的集合，合并所有重叠的区间。

 * 

 *  思路：先对区间排序，按每个区间的start值从小到大排序。然后申请一个新容器，首先把

 *  第一个区间存入容器，然后从第二个区间开始遍历，如果遍历的当前区间的start开始值小于等于

 *  上一个已存入容器区间的结束值end，则说明有重叠部分，容器里区间的end值更新为当前

 *  区间end值和原来值的较大值，如果不重叠，直接将当前区间存入容器中。

 * 

 *  给出C++代码：

 * 

class Solution {

       public:

    staticbool comp(const Interval &a, const Interval &b) {

        return (a.start < b.start);

    }

    vector<Interval>merge(vector<Interval>&intervals) {

        vector<Interval>res;

        if (intervals.empty()) return res;

        sort(intervals.begin(), intervals.end(),comp);

        res.push_back(intervals[0]);

        for (int i = 1; i< intervals.size(); ++i) {

            if (res.back().end >= intervals[i].start) {

                res.back().end = max(res.back().end, intervals[i].end);

            } else {

                res.push_back(intervals[i]);

            }

        }

        return res;

    }

};

 */

classInterval {

       

       intstart;

       

       intend;

       

       Interval() {start = 0; end = 0;};

       

       Interval(ints,int e) {

             

             start= s;

             

             end= e;

       }

}

publicclass Merge_Intervals {

       

       publicArrayList<Interval> merge(ArrayList<Interval>intervals) {

             if(intervals.size() < 2) returnintervals;

             

             //按照区间的start从小到大排序

             Collections.sort(intervals,new Comparator<Interval>() {

                    @Override

                    publicint compare(Interval inter1, Intervalinter2) {

                           if(inter1.start== inter2.start) {

                                 returninter1.end- inter2.end;

                           }

                           returninter1.start- inter2.start;

                    }

             });

             

             //申请一个新的容器来装结果

             ArrayList<Interval>result = newArrayList<Interval>();

             //把第一个区间加入结果集

             result.add(intervals.get(0));

             

             for(inti = 1; i < intervals.size();i++) {

                    //如果结果集中最后一个区间的end大于等于当前遍历区间的start，说明二者有重叠部分

                    if(result.get(result.size() - 1).end>= intervals.get(i).start) {

                           result.get(result.size() - 1).end = Math.max(result.get(result.size() - 1).end,intervals.get(i).end);

                    }else {

                           result.add(intervals.get(i));

                    }

             }

             

             returnresult;

       

    }

   

       publicstatic void main(String[]args) {

             ArrayList<Interval>intervals = newArrayList<Interval>();

             Intervali1 = newInterval(1,3);

             Intervali2 = newInterval(2,6);

             Intervali3 = newInterval(8,10);

             Intervali4 = newInterval(15,18);

             

             intervals.add(i1);

             intervals.add(i2);

             intervals.add(i3);

             intervals.add(i4);

             

             ArrayList<Interval>result = newArrayList<Interval>();

             result= new Merge_Intervals().merge(intervals);

             

             for(inti = 0; i < result.size();i++) {

                    System.out.println("["+ result.get(i).start+

                                 ","+ result.get(i).end+ "]");

             }

             

       }

}