Handling intervals is a must-know pattern for interviews at companies like Google, Facebook, Amazon, etc. Overlapping intervals can show up in many problems like scheduling, range merging, conflict detection, or timeline compression.

📌 What Is the Overlapping Intervals Pattern?

You are given a list of intervals, and your task often revolves around:

  • Merging overlapping intervals
  • Finding if any intervals overlap
  • Finding maximum overlaps
  • Inserting a new interval and merging appropriately
  • Finding non-overlapping intervals

⚙️ Core Strategy

  1. Sort intervals by start time
  2. Iterate through intervals, and:
    • If current overlaps with previous → merge them.
    • Else → add to result list.

🧪 Problem 1: Merge Intervals

Problem: Given intervals = [[1,3],[2,6],[8,10],[15,18]], return merged intervals.

public int[][] merge(int[][] intervals) {
    if (intervals.length <= 1) return intervals;

    Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));
    List<int[]> merged = new ArrayList<>();

    int[] current = intervals[0];

    for (int i = 1; i < intervals.length; i++) {
        if (current[1] >= intervals[i][0]) { // overlap
            current[1] = Math.max(current[1], intervals[i][1]); // merge
        } else {
            merged.add(current);
            current = intervals[i];
        }
    }

    merged.add(current); // add the last merged interval
    return merged.toArray(new int[merged.size()][]);
}

🧠 Key Insight: Overlap occurs when current.end >= next.start.

🧪 Problem 2: Insert and Merge Interval

Problem: Insert a new interval and merge if needed.

Example: [[1,3],[6,9]], newInterval = [2,5] → [[1,5],[6,9]]

public int[][] insert(int[][] intervals, int[] newInterval) {
    List<int[]> result = new ArrayList<>();
    int i = 0;

    // Add all intervals before newInterval
    while (i < intervals.length && intervals[i][1] < newInterval[0]) {
        result.add(intervals[i++]);
    }

    // Merge overlapping intervals with newInterval
    while (i < intervals.length && intervals[i][0] <= newInterval[1]) {
        newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
        newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
        i++;
    }
    result.add(newInterval);

    // Add the rest
    while (i < intervals.length) {
        result.add(intervals[i++]);
    }

    return result.toArray(new int[result.size()][]);
}

🧪 Problem 3: Meeting Rooms (No Overlap Allowed)

Problem: Given meeting intervals, can a person attend all?

public boolean canAttendMeetings(int[][] intervals) {
    Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));

    for (int i = 1; i < intervals.length; i++) {
        if (intervals[i][0] < intervals[i - 1][1]) {
            return false; // overlapping
        }
    }

    return true;
}

🧪 Problem 4: Minimum Number of Meeting Rooms Required

Idea: Count the max number of overlaps at any time.

public int minMeetingRooms(int[][] intervals) {
    int n = intervals.length;
    int[] start = new int[n];
    int[] end = new int[n];

    for (int i = 0; i < n; i++) {
        start[i] = intervals[i][0];
        end[i] = intervals[i][1];
    }

    Arrays.sort(start);
    Arrays.sort(end);

    int rooms = 0, endPtr = 0;

    for (int i = 0; i < n; i++) {
        if (start[i] < end[endPtr]) {
            rooms++; // need new room
        } else {
            endPtr++; // reuse room
        }
    }

    return rooms;
}

🧠 Similar to sweep line algorithm

🧪 Problem 5: Find All Conflicting Appointments 

public void findConflicts(int[][] intervals) {
    Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));

    for (int i = 1; i < intervals.length; i++) {
        if (intervals[i][0] < intervals[i - 1][1]) {
            System.out.println("Conflict: [" + intervals[i][0] + ", " + intervals[i][1] +
                               "] with [" + intervals[i - 1][0] + ", " + intervals[i - 1][1] + "]");
        }
    }
}

📊 Time and Space Complexity

Problem Time Space
Merge Intervals O(n log n) O(n)
Insert and Merge O(n) O(n)
Can Attend All Meetings O(n log n) O(1)
Min Meeting Rooms O(n log n) O(n)

🔗 Real-World Applications

  • Scheduling systems (calendar conflicts, meeting rooms)
  • Video/audio clip merging
  • Range compression (e.g., IP ranges)
  • Job schedulers
  • Reservation systems

💬 Interview Tips

  • Always sort intervals before comparing!
  • Use two pointers or heaps when asked about overlapping counts.
  • Drawing a timeline helps with understanding overlaps.

🧠 Practice Problems

Problem Link
Merge Intervals LeetCode 56
Insert Interval LeetCode 57
Meeting Rooms LeetCode 252
Minimum Meeting Rooms LeetCode 253

✨ Final Words

The Overlapping Intervals pattern is all about sorting and using smart iteration or heaps. Once you get this, you’ll start recognizing this pattern in many tricky questions.

“If it’s intervals — sort them first!” 📅✅