LeetCode:56. Merge Intervals

LeetCode:56. Merge Intervals

Given a collection of intervals, merge all overlapping intervals.

Example 1:

Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].
Example 2:

Input: [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] are considered overlapping.

给定一串区间，如果其中有区间重合则合并区间。（不一定有序）

思路：暴力求解

遍历一次数组，如果不能合并，则压入主栈中。每次遇到一个新区间，都要从主栈中遍历所有区间看能否合并，栈中弹出的不合并的区间暂时保存到另一个辅助栈中，待主栈遍历完成再将辅助栈中元素重新压入主栈。这种方法的时间复杂度是$O(n^2)$。

Python 代码实现

# Definition for an interval.
# class Interval:
#     def __init__(self, s=0, e=0):
#         self.start = s
#         self.end = e

class Solution:
    def toString(self, interval):
        return (interval.start,interval.end)
    
    def canMerge(self,startMerge,nextitem):
        if nextitem.start <= startMerge.end and nextitem.end>=startMerge.start:
            return True
        return False
    
    def mergeTwo(self,startMerge,nextitem):
        start = min(startMerge.start, nextitem.start)
        end = max(startMerge.end, nextitem.end)
        # 合并
        startMerge.start = start
        startMerge.end = end
        return startMerge
    
    def merge(self, intervals: List[Interval]) -> List[Interval]: 
        res = []
        l = len(intervals)
        if l == 0:
            return res
        if l == 1:
            return intervals
        res.append(intervals[0])
        startMerge = intervals[0]
        i = 1
        while i < l:
            tmp = intervals[i]
            tmpStack = []
            while(len(res) > 0):
                top = res.pop()
                if self.canMerge(top,tmp):
                    tmp = self.mergeTwo(top,tmp)
                else:
                    tmpStack.append(top)
            res+=tmpStack   
            res.append(tmp)
            i+=1
            
        return res

思路二：先排序再合并

先按interval的start值升序排列，然后根据end判断能否合并。这种方法的时间复杂度是O(n logn)。

Python 代码实现

class Solution:
    def merge(self, intervals):
        # 按start升序排列
        intervals.sort(key=lambda x: x.start)

        merged = []
        for interval in intervals:
            # if the list of merged intervals is empty or if the current
            # interval does not overlap with the previous, simply append it.
            if not merged or merged[-1].end < interval.start:
                # 不能合并，直接append
                merged.append(interval)
            else:
            # otherwise, there is overlap, so we merge the current and previous
            # intervals.
                # 可以合并，取end较大值
                merged[-1].end = max(merged[-1].end, interval.end)

        return merged

---

THE END.