算法leetcode｜56. 合并区间（rust重拳出击）

---

---

56. 合并区间：

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [start_i, end_i] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

样例 1：

输入：
	
	intervals = [[1,3],[2,6],[8,10],[15,18]]
	
输出：
	
	[[1,6],[8,10],[15,18]]
	
解释：
	
	区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

样例 2：

输入：
	
	intervals = [[1,4],[4,5]]
	
输出：
	
	[[1,5]]
	
解释：
	
	区间 [1,4] 和 [4,5] 可被视为重叠区间。

提示：

• 1 <= intervals.length <= 10⁴
• intervals[i].length == 2
• 0 <= start_i <= end_i <= 10⁴

---

分析：

• 面对这道算法题目，二当家的陷入了沉思。
• 如果没想到排序是比较麻烦的，而下定决定使用排序也不是那么容易，因为排序本身的时间复杂度也不低，但是对于这个情况来说，值了。

---

题解：

rust：

impl Solution {
    
    
    pub fn merge(mut intervals: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    
    
        intervals.sort_unstable();
        let mut ans: Vec<Vec<i32>> = Vec::new();
        let (mut l, mut r) = (intervals[0][0], intervals[0][1]);
        intervals.iter().skip(1).for_each(|cur| {
    
    
            if r < cur[0] {
    
    
                // 没重合
                ans.push(vec![l, r]);
                l = cur[0];
                r = cur[1];
            } else {
    
    
                // 重合
                r = r.max(cur[1]);
            }
        });
        ans.push(vec![l, r]);
        return ans;
    }
}

---

go：

func merge(intervals [][]int) [][]int {
    
    
    sort.Slice(intervals, func(i, j int) bool {
    
    
		return intervals[i][0] < intervals[j][0]
	})
	var ans [][]int
	last := intervals[0]
	for i := 1; i < len(intervals); i++ {
    
    
		cur := intervals[i]
		if last[1] < cur[0] {
    
    
			// 没有重合
			ans = append(ans, last)
			last = cur
		} else {
    
    
			// 有重合
			if cur[1] > last[1] {
    
    
				last[1] = cur[1]
			}
		}
	}
	ans = append(ans, last)
	return ans
}

---

c++：

class Solution {
    
    
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
    
    
        sort(intervals.begin(), intervals.end());
        vector<vector<int>> ans;
        for (int i = 0; i < intervals.size(); ++i) {
    
    
            const int l = intervals[i][0], r = intervals[i][1];
            if (ans.empty() || ans.back()[1] < l) {
    
    
                ans.push_back({
    
    l, r});
            } else {
    
    
                ans.back()[1] = max(ans.back()[1], r);
            }
        }
        return ans;
    }
};

---

python：

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key=lambda x: x[0])
        ans = []
        for interval in intervals:
            if not ans or ans[-1][1] < interval[0]:
                # 不重合
                ans.append(interval)
            else:
                # 重合
                ans[-1][1] = max(ans[-1][1], interval[1])
        return ans

---

java：

class Solution {
    
    
    public int[][] merge(int[][] intervals) {
    
    
        Arrays.sort(intervals, Comparator.comparingInt(o -> o[0]));
        final List<int[]> ans  = new ArrayList<int[]>();
        int[]             last = intervals[0];
        for (int i = 1; i < intervals.length; ++i) {
    
    
            final int[] cur = intervals[i];
            if (last[1] < cur[0]) {
    
    
                // 没重合
                ans.add(last);
                last = cur;
            } else {
    
    
                // 重合
                last[1] = Math.max(last[1], cur[1]);
            }
        }
        ans.add(last);
        return ans.toArray(new int[ans.size()][]);
    }
}

---

非常感谢你阅读本文~
欢迎【点赞】【收藏】【评论】~
放弃不难，但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子：https://le-yi.blog.csdn.net/ 博客原创~

---