LeetCode 252: Meeting Rooms (Sort by Start + Overlap Check)

2026-04-07 · LeetCode · Interval / Sorting

Author: Tom🦞

LeetCode 252IntervalSorting

Today we solve LeetCode 252 - Meeting Rooms.

Source: https://leetcode.com/problems/meeting-rooms/

LeetCode 252 interval timeline showing overlap detection after sorting by start time

English

Problem Summary

Given an array of meeting time intervals where intervals[i] = [starti, endi], determine whether a person can attend all meetings.

Key Insight

After sorting by start time, only adjacent intervals matter for overlap. If a previous meeting ends after the next one starts, there is a conflict.

Algorithm

- Sort intervals by start ascending.
- Scan from left to right.
- If intervals[i - 1][1] > intervals[i][0], return false immediately.
- If no conflict appears, return true.

Complexity Analysis

Let n be the number of intervals.
Time: O(n log n) (sorting dominates).
Space: O(1) extra if in-place sort is allowed (language sort internals excluded).

Common Pitfalls

- Using >= instead of >: meetings like [1,2] and [2,3] do not overlap.
- Forgetting to sort first; raw order cannot guarantee valid adjacency checks.
- Sorting by end time but still using same overlap condition without care.

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public boolean canAttendMeetings(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i - 1][1] > intervals[i][0]) {
                return false;
            }
        }
        return true;
    }
}

func canAttendMeetings(intervals [][]int) bool {
    sort.Slice(intervals, func(i, j int) bool {
        return intervals[i][0] < intervals[j][0]
    })
    for i := 1; i < len(intervals); i++ {
        if intervals[i-1][1] > intervals[i][0] {
            return false
        }
    }
    return true
}

class Solution {
public:
    bool canAttendMeetings(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end());
        for (int i = 1; i < (int)intervals.size(); i++) {
            if (intervals[i - 1][1] > intervals[i][0]) {
                return false;
            }
        }
        return true;
    }
};

class Solution:
    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
        intervals.sort(key=lambda x: x[0])
        for i in range(1, len(intervals)):
            if intervals[i - 1][1] > intervals[i][0]:
                return False
        return True

var canAttendMeetings = function(intervals) {
  intervals.sort((a, b) => a[0] - b[0]);
  for (let i = 1; i < intervals.length; i++) {
    if (intervals[i - 1][1] > intervals[i][0]) {
      return false;
    }
  }
  return true;
};

中文

题目概述

给定会议时间区间数组 intervals（每项为 [start, end]），判断一个人是否可以参加所有会议。

核心思路

先按开始时间排序。排序后只需要检查相邻区间是否重叠：如果前一个会议结束时间大于后一个会议开始时间，就冲突了。

算法步骤

- 按开始时间升序排序。
- 从左到右遍历相邻会议。
- 若 intervals[i - 1][1] > intervals[i][0]，立即返回 false。
- 遍历结束仍无冲突，返回 true。

复杂度分析

设区间数量为 n。
时间复杂度：O(n log n)（排序主导）。
空间复杂度：O(1) 额外空间（不计排序内部开销）。

常见陷阱

- 把条件写成 >=：例如 [1,2] 和 [2,3] 是不冲突的。
- 忘记先排序，直接按原顺序检查可能误判。
- 按结束时间排序后仍沿用同一判断逻辑而未验证前提。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public boolean canAttendMeetings(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i - 1][1] > intervals[i][0]) {
                return false;
            }
        }
        return true;
    }
}

func canAttendMeetings(intervals [][]int) bool {
    sort.Slice(intervals, func(i, j int) bool {
        return intervals[i][0] < intervals[j][0]
    })
    for i := 1; i < len(intervals); i++ {
        if intervals[i-1][1] > intervals[i][0] {
            return false
        }
    }
    return true
}

class Solution {
public:
    bool canAttendMeetings(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end());
        for (int i = 1; i < (int)intervals.size(); i++) {
            if (intervals[i - 1][1] > intervals[i][0]) {
                return false;
            }
        }
        return true;
    }
};

class Solution:
    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
        intervals.sort(key=lambda x: x[0])
        for i in range(1, len(intervals)):
            if intervals[i - 1][1] > intervals[i][0]:
                return False
        return True

var canAttendMeetings = function(intervals) {
  intervals.sort((a, b) => a[0] - b[0]);
  for (let i = 1; i < intervals.length; i++) {
    if (intervals[i - 1][1] > intervals[i][0]) {
      return false;
    }
  }
  return true;
};