Why Merge Overlapping Intervals in DSA C?

The Big Idea

What if you could instantly combine all overlapping times without missing a single conflict?

The Scenario

Imagine you have a list of booked meeting times in a day, but some meetings overlap. You want to find the total free time, but first, you need to merge all overlapping meetings into one.

The Problem

Manually checking each meeting against all others to merge overlaps is slow and confusing. It's easy to miss overlaps or merge incorrectly, especially when many meetings are involved.

The Solution

Using the merge overlapping intervals method, you sort the meetings by start time and then combine any that overlap in one pass. This makes the process fast, clear, and error-free.

Before vs After

✗ Before

for (int i = 0; i < n; i++) {
  for (int j = i + 1; j < n; j++) {
    if (intervals[i] overlaps intervals[j]) {
      merge intervals[i] and intervals[j];
    }
  }
}

✓ After

sort intervals by start time;
vector<Interval> merged;
merged.push_back(intervals[0]);
for (int i = 1; i < n; i++) {
  if (intervals[i].start <= merged.back().end) {
    merged.back().end = max(merged.back().end, intervals[i].end);
  } else {
    merged.push_back(intervals[i]);
  }
}

What It Enables

This method lets you quickly find combined time blocks, making scheduling, resource allocation, and timeline analysis simple and reliable.

Real Life Example

When booking rooms for events, merging overlapping bookings helps find free slots without conflicts, ensuring smooth planning.

Key Takeaways

Manual merging is slow and error-prone.

Sorting intervals first simplifies merging.

One pass after sorting merges all overlaps efficiently.