📊 Merge Intervals

Sort + Merge Overlapping Ranges

Day 2/6 Pattern: Interval Merging

📖 Pattern Overview

🎯 When to Use

  • Merging overlapping intervals
  • Scheduling meetings
  • Finding free time slots
  • Resource allocation

⚡ Complexity

  • Time: O(n log n)
  • Space: O(n)
  • Key: Sort first!
  • Why: Sorting enables linear merge

🔑 How It Works

  • Step 1: Sort by start time
  • Step 2: Iterate through intervals
  • Step 3: Merge if overlapping
  • Step 4: Add to result

🎯 Select Problem

Merge Intervals

Normal
Total Intervals: 0
Current Step: 0
Merged Count: 0
Result: -

Current Step:

Click "Start" or "Step" to begin the algorithm

🎨 Custom Input

Quick Presets:

📚 LeetCode Problems

56. Merge Intervals

Medium

Given intervals, merge all overlapping intervals.

Solve on LeetCode →

57. Insert Interval

Medium

Insert new interval and merge if necessary.

Solve on LeetCode →

252. Meeting Rooms

Easy

Check if person can attend all meetings.

Solve on LeetCode →

253. Meeting Rooms II

Medium

Find minimum number of conference rooms required.

Solve on LeetCode →

435. Non-overlapping Intervals

Medium

Find minimum removals to make intervals non-overlapping.

Solve on LeetCode →

986. Interval List Intersections

Medium

Find intersections of two interval lists.

Solve on LeetCode →

🧠 Algorithm Deep Dive

Core Algorithm

The key insight: Sort by start time, then merge in one pass!

function merge(intervals) {
    if (intervals.length === 0) return [];
    
    // Step 1: Sort by start time
    intervals.sort((a, b) => a[0] - b[0]);
    
    const result = [intervals[0]];
    
    // Step 2: Iterate and merge
    for (let i = 1; i < intervals.length; i++) {
        const current = intervals[i];
        const last = result[result.length - 1];
        
        // Check overlap: current starts before last ends
        if (current[0] <= last[1]) {
            // Merge: extend the end time
            last[1] = Math.max(last[1], current[1]);
        } else {
            // No overlap: add as new interval
            result.push(current);
        }
    }
    
    return result;
}

Meeting Rooms II (Min Rooms Required)

Use a min-heap to track room end times efficiently!

function minMeetingRooms(intervals) {
    if (intervals.length === 0) return 0;
    
    // Sort by start time
    intervals.sort((a, b) => a[0] - b[0]);
    
    // Min-heap for end times
    const rooms = [intervals[0][1]];
    
    for (let i = 1; i < intervals.length; i++) {
        // If earliest ending meeting ends before this starts
        if (rooms[0] <= intervals[i][0]) {
            rooms.shift(); // Room freed
        }
        
        // Add current meeting's end time
        rooms.push(intervals[i][1]);
        rooms.sort((a, b) => a - b); // Keep as min-heap
    }
    
    return rooms.length; // Peak number of rooms
}

Real-World Applications

  • Calendar Apps: Google Calendar merges events, finds free slots
  • Resource Scheduling: Conference room booking systems
  • CPU Scheduling: Operating systems schedule processes
  • Video Streaming: Merge buffered segments
  • Data Compression: Merge consecutive data ranges