Introduction

Merging overlapping time ranges is a standard interval problem. It shows up in booking systems, uptime reports, employee schedules, and log analysis, where several small intervals need to be collapsed into the smallest set of continuous ranges.

Sort First, Then Scan Once

The clean solution is to sort intervals by start time and then walk through them once. Sorting matters because once the ranges are ordered, any overlap can only happen with the interval most recently added to the result.

Suppose the input is [(1, 3), (2, 5), (8, 10), (9, 12)]. After sorting, the first two intervals overlap and become (1, 5). The last two overlap and become (8, 12). The final result is [(1, 5), (8, 12)].

The key rule is simple: if the next interval starts before or at the end of the last merged interval, extend the last merged interval. Otherwise, start a new merged interval.

Python Implementation

1from typing import Iterable, List, Tuple
2
3Range = Tuple[int, int]
4
5
6def merge_ranges(ranges: Iterable[Range]) -> List[Range]:
7    ordered = sorted(ranges, key=lambda item: item[0])
8    if not ordered:
9        return []
10
11    merged: List[Range] = [ordered[0]]
12
13    for start, end in ordered[1:]:
14        last_start, last_end = merged[-1]
15        if start <= last_end:
16            merged[-1] = (last_start, max(last_end, end))
17        else:
18            merged.append((start, end))
19
20    return merged
21
22
23print(merge_ranges([(8, 10), (1, 3), (2, 5), (9, 12)]))

Output:

[(1, 5), (8, 12)]

The time complexity is dominated by sorting, so the full algorithm is O(n log n). The scan itself is linear.

Working With Real Timestamps

In real applications, you usually work with datetime values rather than integers. The algorithm stays the same because Python can compare datetime objects directly.

1from datetime import datetime
2
3intervals = [
4    (datetime(2026, 3, 11, 9, 0), datetime(2026, 3, 11, 10, 0)),
5    (datetime(2026, 3, 11, 9, 30), datetime(2026, 3, 11, 11, 0)),
6    (datetime(2026, 3, 11, 13, 0), datetime(2026, 3, 11, 14, 0)),
7]
8
9print(merge_ranges(intervals))

That produces two merged blocks: one morning block and one afternoon block.

Decide Whether Touching Ranges Should Merge

A practical detail is how to treat touching intervals. If one range ends at 10:00 and the next starts at 10:00, some systems consider them continuous and merge them. Others keep them separate.

The current implementation merges touching ranges because it uses start <= last_end. If you want strict overlap only, change the test to start < last_end.

That choice is business logic, not algorithm logic. Calendar applications often keep touching meetings separate, while billing windows or machine uptime windows often merge them.

Why This Approach Is Better Than Pairwise Comparison

A common first attempt compares every interval with every other interval and repeatedly merges matches. That works for small inputs, but it is slower and much harder to reason about. Repeated pairwise merging can also create subtle bugs when one merged range now overlaps a later interval that was already checked.

Sorting once avoids that mess. At any point, the only interval that matters is the last merged one. That makes the code easier to test and easier to explain.

Common Pitfalls

The most common bug is forgetting to sort before merging. Without sorting, you can merge some overlaps and still leave others fragmented because intervals arrive in an arbitrary order.

Another mistake is not validating that each tuple has start <= end. If bad input is possible, normalize or reject it before merging.

Developers also often hard-code the inclusive boundary rule without confirming requirements. Whether touching intervals merge should be explicit, because changing <= to < changes the result for edge cases.

Finally, watch time zones when using datetime. Mixing naive and timezone-aware timestamps can raise errors or create incorrect ordering.

Summary

• Sort intervals by start time before merging.
• Scan once and compare each range with the last merged range.
• The standard solution runs in O(n log n) time.
• '<= merges touching ranges, while < keeps them separate.'
• The same algorithm works for integers, floats, and datetime values.