merge-intervals

package com.ytx.array;

import java.util.ArrayList;

import java.util.Collections;

import java.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].

 *

 * @author yuantian xin

 * 

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

 * 

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

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

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

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

 * 

 *  给出C++代码：

 * 

class Solution {

       public:

    static bool 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;

    }

};

 */

class Interval {

       

       int start;

       

       int end;

       

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

       

       Interval(int s, int e) {

             

             start = s;

             

             end = e;

       }

}

public class Merge_Intervals {

       

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

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

             

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

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

                    @Override

                    public int compare(Interval inter1, Interval inter2) {

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

                                 return inter1.end - inter2.end;

                           }

                           return inter1.start - inter2.start;

                    }

             });

             

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

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

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

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

             

             for(int i = 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));

                    }

             }

             

             return result;

       

    }

   

       public static void main(String[] args) {

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

             Interval i1 = new Interval(1,3);

             Interval i2 = new Interval(2,6);

             Interval i3 = new Interval(8,10);

             Interval i4 = new Interval(15,18);

             

             intervals.add(i1);

             intervals.add(i2);

             intervals.add(i3);

             intervals.add(i4);

             

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

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

             

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

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

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

             }

             

       }

}