Insert Interval into Sorted List in DSA Go - Time & Space Complexity

Time Complexity: Insert Interval into Sorted List

O(n)

Understanding Time Complexity

We want to understand how the time needed to insert a new interval into a sorted list of intervals grows as the list gets bigger.

Specifically, how does the number of steps change when we add more intervals?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func insertInterval(intervals [][]int, newInterval []int) [][]int {
    var result [][]int
    i := 0
    n := len(intervals)

    for i < n && intervals[i][1] < newInterval[0] {
        result = append(result, intervals[i])
        i++
    }

    for i < n && intervals[i][0] <= newInterval[1] {
        newInterval[0] = min(newInterval[0], intervals[i][0])
        newInterval[1] = max(newInterval[1], intervals[i][1])
        i++
    }

    result = append(result, newInterval)

    for i < n {
        result = append(result, intervals[i])
        i++
    }

    return result
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

This code inserts a new interval into a sorted list of intervals, merging overlapping intervals as needed.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Three separate loops that each traverse parts of the intervals list.
• How many times: Each loop runs over a portion of the list without overlap, together covering all intervals once.

How Execution Grows With Input

As the number of intervals (n) grows, the code checks each interval at most once in one of the loops.

Input Size (n)	Approx. Operations
10	About 10 checks and merges
100	About 100 checks and merges
1000	About 1000 checks and merges

Pattern observation: The number of operations grows roughly in direct proportion to the number of intervals.

Final Time Complexity

Time Complexity: O(n)

This means the time to insert and merge intervals grows linearly with the number of intervals in the list.

Common Mistake

[X] Wrong: "Since there are three loops, the time complexity is O(3n) or O(n^2)."

[OK] Correct: The loops run one after another and together cover each interval only once, so the total work is proportional to n, not n squared.

Interview Connect

Understanding this linear time complexity helps you explain how your solution efficiently handles merging intervals without unnecessary repeated work.

Self-Check

"What if the intervals list was not sorted? How would the time complexity change?"

Practice

1. What is the main goal when inserting a new interval into a sorted list of non-overlapping intervals?

easy

A. To merge overlapping intervals and keep the list sorted

B. To add the new interval at the end without merging

C. To remove all intervals that come before the new interval

D. To sort the list again after insertion

Solution

1. Step 1: Understand the problem context

   The list contains sorted, non-overlapping intervals. Inserting a new interval may cause overlaps.

2. Step 2: Determine the correct action

   We must merge any overlapping intervals with the new one to keep the list sorted and non-overlapping.

3. Final Answer:

   To merge overlapping intervals and keep the list sorted -> Option A

4. Quick Check:

   Insert interval = merge and keep sorted [OK]

Hint: Merge overlaps to keep intervals sorted and non-overlapping [OK]

Common Mistakes:

• Just appending without merging
• Removing intervals incorrectly
• Sorting again after insertion

2. Which Go syntax correctly declares a slice of intervals where each interval is a slice of two integers?

easy

A. intervals := [][2]int{{1, 3}, {6, 9}}

B. intervals := [][]int{1, 3, 6, 9}

C. intervals := []int{1, 3, 6, 9}

D. intervals := [][]int{{1, 3}, {6, 9}}

Solution

1. Step 1: Identify slice of slices syntax

   In Go, [][]int means a slice of slices of int, suitable for intervals like [start, end].

2. Step 2: Check each option

   intervals := [][]int{{1, 3}, {6, 9}} correctly uses [][]int with nested slices for intervals. intervals := [][2]int{{1, 3}, {6, 9}} uses array [2]int which is valid but less common. intervals := []int{1, 3, 6, 9} is a flat slice, not intervals. intervals := [][]int{1, 3, 6, 9} is invalid syntax.

3. Final Answer:

   intervals := [][]int{{1, 3}, {6, 9}} -> Option D

4. Quick Check:

   Slice of slices = [][]int{{start,end}} [OK]

Hint: Use [][]int for slice of intervals in Go [OK]

Common Mistakes:

• Using flat []int instead of [][]int
• Incorrect array vs slice syntax
• Missing curly braces for nested slices

3. What is the output of the following Go code snippet after inserting interval [2,5] into intervals [[1,2],[6,9]]?

intervals := [][]int{{1, 2}, {6, 9}}
newInterval := []int{2, 5}
// After insertion and merging
result := [][]int{{1, 5}, {6, 9}}
fmt.Println(result)

medium

A. [[1 2] [6 9] [2 5]]

B. [[1 2] [2 5] [6 9]]

C. [[1 5] [6 9]]

D. [[2 5] [6 9]]

Solution

1. Step 1: Insert and check overlap

   New interval [2,5] overlaps with [1,2] because 2 <= 2. Merge them to [1,5].

2. Step 2: Keep other intervals

   [6,9] does not overlap with [1,5], so it stays as is.

3. Final Answer:

   [[1 5] [6 9]] -> Option C

4. Quick Check:

   Merged intervals = [[1 5] [6 9]] [OK]

Hint: Merge overlapping intervals to combine ranges [OK]

Common Mistakes:

• Not merging overlapping intervals
• Appending new interval without sorting
• Incorrect interval order

4. Given this Go function snippet to insert an interval, what is the bug?

func insert(intervals [][]int, newInterval []int) [][]int {
    var result [][]int
    for _, interval := range intervals {
        if interval[1] < newInterval[0] {
            result = append(result, interval)
        } else if interval[0] > newInterval[1] {
            result = append(result, newInterval)
            newInterval = interval
        } else {
            newInterval[0] = min(newInterval[0], interval[0])
            newInterval[1] = max(newInterval[1], interval[1])
        }
    }
    result = append(result, newInterval)
    return result
}

medium

A. Appending newInterval multiple times causes duplicates

B. Not updating newInterval correctly during merge

C. Missing return statement

D. Incorrect comparison operators in if conditions

Solution

1. Step 1: Analyze appending logic

   When interval[0] > newInterval[1], newInterval is appended and then replaced by interval. This can cause multiple appends of newInterval.

2. Step 2: Identify duplicate insertion

   Because newInterval is appended inside the loop multiple times, duplicates appear in result.

3. Final Answer:

   Appending newInterval multiple times causes duplicates -> Option A

4. Quick Check:

   Multiple appends = duplicates [OK]

Hint: Append newInterval once after loop to avoid duplicates [OK]

Common Mistakes:

• Appending inside loop multiple times
• Not updating newInterval boundaries
• Forgetting to return result

5. You have intervals [[1,3],[6,9]] and want to insert [2,7]. What is the final list after insertion and merging?

hard

A. [[1,3],[2,7],[6,9]]

B. [[1,9]]

C. [[1,7],[6,9]]

D. [[1,9],[6,9]]

Solution

1. Step 1: Merge [2,7] with overlapping intervals

   [2,7] overlaps with [1,3] and [6,9]. Merge all three intervals into one covering from min start 1 to max end 9.

2. Step 2: Final merged interval

   The merged interval is [1,9], replacing the original two intervals.

3. Final Answer:

   [[1,9]] -> Option B

4. Quick Check:

   Merge all overlapping = [[1,9]] [OK]

Hint: Merge all overlapping intervals into one big interval [OK]

Common Mistakes:

• Partial merges leaving overlaps
• Appending without merging
• Incorrect interval boundaries