Merge Overlapping Intervals in DSA Typescript - Execution Trace

Concept Flow - Merge Overlapping Intervals

Sort intervals by start

↓

Initialize merged list with first interval

↓

For each next interval

↓

Check overlap with last merged

↓

Merge intervals

↓

Repeat

↓

Return merged

Sort intervals, then scan each interval to merge if overlapping or add if separate.

Execution Sample

DSA Typescript

function mergeIntervals(intervals: number[][]): number[][] {
  intervals.sort((a, b) => a[0] - b[0]);
  const merged = [intervals[0]];
  for (let i = 1; i < intervals.length; i++) {
    const last = merged[merged.length - 1];
    if (intervals[i][0] <= last[1]) {
      last[1] = Math.max(last[1], intervals[i][1]);
    } else {
      merged.push(intervals[i]);
    }
  }
  return merged;
}

Sort intervals by start, then merge overlapping intervals into one.

Execution Table

Step	Operation	Current Interval	Last Merged Interval	Action	Merged List State
1	Sort intervals	[1,3], [2,6], [8,10], [15,18]	N/A	Sorted intervals	[]
2	Initialize merged	[1,3]	N/A	Add first interval	[[1,3]]
3	Check overlap	[2,6]	[1,3]	Overlap detected, merge	[[1,6]]
4	Check overlap	[8,10]	[1,6]	No overlap, add interval	[[1,6],[8,10]]
5	Check overlap	[15,18]	[8,10]	No overlap, add interval	[[1,6],[8,10],[15,18]]
6	Return result	N/A	N/A	Return merged intervals	[[1,6],[8,10],[15,18]]

💡 All intervals processed, merged list returned

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
intervals	[[1,3],[2,6],[8,10],[15,18]]	[[1,3],[2,6],[8,10],[15,18]]	[[1,3],[2,6],[8,10],[15,18]]	[[1,3],[2,6],[8,10],[15,18]]	[[1,3],[2,6],[8,10],[15,18]]	[[1,3],[2,6],[8,10],[15,18]]
merged	[]	[[1,3]]	[[1,6]]	[[1,6],[8,10]]	[[1,6],[8,10],[15,18]]	[[1,6],[8,10],[15,18]]
last	N/A	[1,3]	[1,6]	[8,10]	[15,18]	[15,18]
current interval	N/A	[2,6]	[8,10]	[15,18]	N/A	N/A

Key Moments - 3 Insights

Why do we sort intervals before merging?

Sorting ensures intervals are in order by start time, so overlapping intervals come one after another, making it easy to merge as shown in step 1 of execution_table.

Why do we compare current interval start with last merged interval end?

Because overlap happens if current start is less or equal to last merged end, as checked in steps 3-5 in execution_table, guiding whether to merge or add.

How does merging update the last interval in merged list?

When overlapping, we update the end of last merged interval to the max end between last merged and current interval, shown in step 3 where [1,3] becomes [1,6].

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the merged list state after merging?

A [[1,3],[2,6]]

B [[1,6]]

C [[2,6]]

D [[1,3]]

💡 Hint

Check the 'Merged List State' column at step 3 in execution_table

At which step does the condition for no overlap occur?

A Step 4

B Step 3

C Step 2

D Step 1

💡 Hint

Look at the 'Action' column in execution_table where it says 'No overlap, add interval'

If the intervals were not sorted first, what would happen to the merging process?

A Merging would still work correctly

B The merged list would be empty

C Some overlapping intervals might not merge properly

D The code would throw an error

💡 Hint

Refer to the 'Sort intervals' operation in step 1 of execution_table and key_moments about sorting importance

Concept Snapshot

Merge Overlapping Intervals:
- Sort intervals by start time
- Initialize merged list with first interval
- For each next interval:
  - If overlapping with last merged, merge by updating end
  - Else, add as new interval
- Return merged list
Key: sorting ensures correct merging order

Full Transcript

To merge overlapping intervals, first sort all intervals by their start times. Then, start with the first interval in a new merged list. For each next interval, check if it overlaps with the last interval in the merged list by comparing the current interval's start with the last merged interval's end. If they overlap, merge them by updating the end of the last merged interval to the maximum end of both. If not overlapping, add the current interval to the merged list. Continue until all intervals are processed. Finally, return the merged list. Sorting is crucial to ensure intervals are processed in order, so overlaps are detected correctly.

Practice

1. What is the main purpose of merging overlapping intervals in a list of intervals?

easy

A. To split intervals into smaller parts

B. To sort intervals by their end times only

C. To remove all intervals that have the same start time

D. To combine intervals that overlap into a single continuous interval

Solution

1. Step 1: Understand overlapping intervals

   Overlapping intervals share some common range, so merging combines them into one continuous interval.

2. Step 2: Purpose of merging

   Merging removes overlaps by creating a single interval covering all overlapping parts.

3. Final Answer:

   To combine intervals that overlap into a single continuous interval -> Option D

4. Quick Check:

   Merging = Combine overlaps [OK]

Hint: Merge means combine overlapping parts into one [OK]

Common Mistakes:

• Thinking merging sorts intervals only
• Confusing merging with removing duplicates
• Believing merging splits intervals

2. Which of the following TypeScript code snippets correctly sorts an array of intervals by their start time?

easy

A. intervals.sort((a, b) => a[0] - b[0]);

B. intervals.sort((a, b) => b[1] - a[1]);

C. intervals.sort((a, b) => a[1] + b[0]);

D. intervals.sort((a, b) => a[0] + b[1]);

Solution

1. Step 1: Identify sorting by start time

   Sorting by start time means comparing the first element of each interval (a[0] and b[0]).

2. Step 2: Check correct comparison function

   Subtracting a[0] - b[0] sorts ascending by start time, which is correct.

3. Final Answer:

   intervals.sort((a, b) => a[0] - b[0]); -> Option A

4. Quick Check:

   Sort by start = a[0] - b[0] [OK]

Hint: Sort intervals by start using a[0] - b[0] [OK]

Common Mistakes:

• Sorting by end time instead of start time
• Adding values instead of subtracting in sort
• Using wrong indices for comparison

3. What is the output of the following TypeScript code?

function mergeIntervals(intervals: number[][]): number[][] {
  intervals.sort((a, b) => a[0] - b[0]);
  const merged: number[][] = [];
  for (const interval of intervals) {
    if (!merged.length || merged[merged.length - 1][1] < interval[0]) {
      merged.push(interval);
    } else {
      merged[merged.length - 1][1] = Math.max(merged[merged.length - 1][1], interval[1]);
    }
  }
  return merged;
}

console.log(mergeIntervals([[1,3],[2,6],[8,10],[15,18]]));

medium

A. [[1,3],[2,6],[8,10],[15,18]]

B. [[1,10],[15,18]]

C. [[1,6],[8,10],[15,18]]

D. [[2,6],[8,10],[15,18]]

Solution

1. Step 1: Sort intervals by start

   Sorted intervals: [[1,3],[2,6],[8,10],[15,18]] (already sorted)

2. Step 2: Merge overlapping intervals

   First interval [1,3] added.
   Second interval [2,6] overlaps with [1,3], merge to [1,6].
   Third interval [8,10] no overlap, add.
   Fourth interval [15,18] no overlap, add.

3. Final Answer:

   [[1,6],[8,10],[15,18]] -> Option C

4. Quick Check:

   Merged intervals = [[1,6],[8,10],[15,18]] [OK]

Hint: Sort first, then merge overlapping intervals step-by-step [OK]

Common Mistakes:

• Not sorting intervals before merging
• Overwriting intervals incorrectly
• Missing to merge overlapping intervals

4. The following TypeScript function is intended to merge overlapping intervals but has a bug. What is the bug?

function merge(intervals: number[][]): number[][] {
  intervals.sort((a, b) => a[0] - b[0]);
  const result: number[][] = [];
  for (let i = 0; i < intervals.length; i++) {
    if (result.length === 0 || result[result.length - 1][1] <= intervals[i][0]) {
      result.push(intervals[i]);
    } else {
      result[result.length - 1][1] = Math.max(result[result.length - 1][1], intervals[i][1]);
    }
  }
  return result;
}

medium

A. The max function is used incorrectly

B. The condition should use '<' instead of '<=' to detect overlap

C. The function does not handle empty input

D. The intervals are not sorted before merging

Solution

1. Step 1: Analyze overlap condition

   Condition uses '<=' which treats touching intervals as non-overlapping.

2. Step 2: Correct overlap detection

   Correct condition uses '<' so that when last_end == current_start (touching), it merges since the if condition fails and goes to else. Current '<=' incorrectly pushes new for touching intervals.

3. Final Answer:

   The condition should use '<' instead of '<=' to detect overlap -> Option B

4. Quick Check:

   Overlap check needs '<' not '<=' [OK]

Hint: Use '<' to detect overlap, not '<=' [OK]

Common Mistakes:

• Using '<=' causes missing merges on touching intervals
• Ignoring sorting requirement
• Not checking empty input but that is not the bug here

5. Given a list of intervals, how would you modify the merge overlapping intervals algorithm to also count how many original intervals were merged into each resulting interval?
Choose the best approach.

hard

A. Keep a count alongside each merged interval and increment it when merging overlaps

B. Sort intervals by end time instead of start time

C. Use a separate array to store counts and update only after merging all intervals

D. Merge intervals normally and count the total number of intervals merged at the end

Solution

1. Step 1: Track counts during merging

   When merging intervals, keep a count for each merged interval starting at 1.

2. Step 2: Increment count on overlap

   Each time an interval merges into the last merged interval, increment its count to reflect how many intervals combined.

3. Final Answer:

   Keep a count alongside each merged interval and increment it when merging overlaps -> Option A

4. Quick Check:

   Count merges while merging intervals [OK]

Hint: Track counts during merge, increment on overlap [OK]

Common Mistakes:

• Sorting by end time does not help counting merges
• Counting after merging loses interval mapping
• Counting total merges instead of per merged interval