The core approach: Insert Interval is solved with a single linear scan in O(n) time and O(n) space. Append all intervals ending before the new one, then merge all overlapping intervals by extending the new interval's bounds, then append the remainder. The overlapping constraint is handled by comparing start and end values during the merge phase.

You’re in a coding interview. The interviewer says: “You have a list of non-overlapping intervals sorted by start time. Insert a new interval and merge any overlaps.” You know this is a linear scan — no sort needed because the input is already sorted. The challenge is the boundary conditions: when does the new interval overlap, when does the current interval go before it, and when does it go after?

---

Already know how to solve Insert Interval? Try a Insert Interval mock interview on Intervu →

The Problem

You are given an array of non-overlapping intervals intervals sorted in ascending order by start time, and a new interval newInterval. Insert newInterval into intervals, merging any overlapping intervals.

Example

Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8] Output: [[1,2],[3,10],[12,16]]

---

What Interviewers Are Actually Testing

Skill	What Interviewers Observe
Case analysis	Do you identify the three cases cleanly?
Boundary conditions	Do you use <= vs. < correctly for overlap?
No re-sort	Do you recognize no sort step is needed?
Edge cases	Empty intervals, newInterval before/after all?

---

Step 1: The Three Cases

For each existing interval relative to newInterval:

1. Ends before (curr[1] < new_start): no overlap, add as-is.
2. Overlaps (curr[0] <= new_end): merge by expanding bounds.
3. Starts after (curr[0] > new_end): insert merged newInterval, then add rest.

---

Step 2: The Key Insight

Treat the insertion as a running interval that expands as it absorbs overlapping neighbors. Scan left to right — anything before gets added directly, anything overlapping merges, everything after the overlap triggers the insertion.

---

Python Implementation

def insert(intervals: list[list[int]], newInterval: list[int]) -> list[list[int]]:
    result = []
    i = 0
    n = len(intervals)

    # Add intervals that end before newInterval starts
    while i < n and intervals[i][1] < newInterval[0]:
        result.append(intervals[i])
        i += 1

    # Merge overlapping intervals
    while i < n and intervals[i][0] <= newInterval[1]:
        newInterval[0] = min(intervals[i][0], newInterval[0])
        newInterval[1] = max(intervals[i][1], newInterval[1])
        i += 1

    result.append(newInterval)

    # Add remaining intervals
    result.extend(intervals[i:])
    return result

---

Time & Space Complexity

Aspect	Complexity
Time	O(n) — single scan
Space	O(n) — output list

---

Common Interview Mistakes

1. Wrong overlap condition. Use <= not < — adjacent intervals like [1,3] and [3,5] should merge.
2. Forgetting to append merged interval. Many candidates exit the merge loop and skip appending newInterval.
3. Unnecessary sort. Input is already sorted — sorting costs O(n log n) for no reason.

---

What a Strong Candidate Sounds Like

“The input is already sorted, so I scan left to right in O(n). Three cases: intervals ending before the new one get added as-is, overlapping ones merge by expanding bounds, and once past the overlap I insert the merged interval and append the rest.”

---

Example Interview Dialogue

Interviewer: What’s the overlap condition?

Candidate: Two intervals [a,b] and [c,d] overlap if c <= b — the second starts no later than the first ends. I use intervals[i][0] <= newInterval[1] in the merge loop.

---

Related Problems to Practice

• Merge Intervals — Same merging logic on unsorted input.
• Meeting Rooms — Interval overlap detection.

---

Frequently Asked Questions

What is the time complexity of the Insert Interval algorithm?

Because the problem enforces that the original intervals remain strictly sorted, an optimal linear scan algorithm completes the insertion in definitive O(N) execution time without requiring a secondary O(N log N) sorting step.

How does an optimal Insert Interval logic handle overlapping boundaries?

The core insight is checking when a new boundary overlaps an existing index (i.e. new_interval[0] <= current_interval[1]). You iteratively evaluate and extend the maximum bounds into a merged chunk before passing it onto the finalized array sequence.

Practice This in a Mock Interview

Start a mock interview for Insert Interval on Intervu.

---

Further reading:

• How to Prepare for a Coding Interview in 2026, the complete roadmap
• Why LeetCode alone isn’t enough, and what to practice instead
• Practice any LeetCode problem as a live mock interview
• The Grind 75 Pathway, a structured study plan with AI practice links
• Browse all walkthroughs on GitHub, condensed solutions with code