🧠 Mastering Overlapping Intervals (Complete Guide with Java Examples)

Yodgorbek Komilov

3 min read

·

Mar 27, 2026

--

Listen

Share

If you’re preparing for coding interviews (FAANG level), Overlapping Intervals is a pattern you cannot skip.

This post will teach you:

• What overlapping intervals are
• Where they are used in real life
• How to solve them using a reusable pattern
• 4 real LeetCode problems with full Java code (including main methods)

📌 What is an Overlapping Interval?

An interval is a pair of numbers representing a range:

[start, end]

Two intervals overlap if:

next.start <= current.end

🌍 Real-Life Use Cases

This pattern is not just for interviews — it’s everywhere:

• 📅 Calendar scheduling (Google Calendar conflicts)
• 🏨 Booking systems (hotel reservations)
• 🧠 Memory allocation (OS systems)
• 🚗 Ride-sharing time slots
• 📊 Data range merging

⚙️ Core Idea (Golden Pattern)

Almost every interval problem follows:

1. Sort intervals
2. Iterate
3. Merge / Compare / Count

🧩 Problem 1: Merge Intervals (LeetCode 56)

🧠 Problem

Merge all overlapping intervals.

💻 Java Implementation

import java.util.*;

public class MergeIntervals {

    public static int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

        List<int[]> result = new ArrayList<>();
        int[] current = intervals[0];

        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i][0] <= current[1]) {
                current[1] = Math.max(current[1], intervals[i][1]);
            } else {
                result.add(current);
                current = intervals[i];
            }
        }

        result.add(current);
        return result.toArray(new int[result.size()][]);
    }

    public static void main(String[] args) {
        int[][] intervals = {{1,3},{2,6},{8,10},{15,18}};

        int[][] merged = merge(intervals);

        System.out.println("Merged intervals:");
        for (int[] i : merged) {
            System.out.println(Arrays.toString(i));
        }
    }
}

🧩 Problem 2: Non-overlapping Intervals (LeetCode 435)

🧠 Problem

Remove minimum intervals so that no intervals overlap.

🔥 Key Idea

Sort by end time (greedy)

Java Implementation

import java.util.*;

public class NonOverlappingIntervals {

    public static int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> a[1] - b[1]); // sort by end

        int count = 0;
        int end = intervals[0][1];

        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i][0] < end) {
                count++; // remove this interval
            } else {
                end = intervals[i][1]; // update end
            }
        }

        return count;
    }

    public static void main(String[] args) {
        int[][] intervals = {{1,2},{2,3},{3,4},{1,3}};

        int removed = eraseOverlapIntervals(intervals);

        System.out.println("Minimum intervals to remove: " + removed);
    }
}

🧩 Problem 3: Meeting Rooms (LeetCode 252)

🧠 Problem

Can a person attend all meetings?

💻 Java Implementation

import java.util.*;

public class MeetingRooms {

    public static boolean canAttendMeetings(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i][0] < intervals[i - 1][1]) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
        int[][] intervals = {{0,30},{5,10},{15,20}};

        boolean result = canAttendMeetings(intervals);

        System.out.println("Can attend all meetings: " + result);
    }
}

🧩 Problem 4: Interval Intersection (LeetCode 986)

🧠 Problem

Find intersection of two interval lists.

import java.util.*;

public class IntervalIntersection {

    public static int[][] intervalIntersection(int[][] A, int[][] B) {
        List<int[]> result = new ArrayList<>();

        int i = 0, j = 0;

        while (i < A.length && j < B.length) {
            int start = Math.max(A[i][0], B[j][0]);
            int end = Math.min(A[i][1], B[j][1]);

            if (start <= end) {
                result.add(new int[]{start, end});
            }

            if (A[i][1] < B[j][1]) {
                i++;
            } else {
                j++;
            }
        }

        return result.toArray(new int[result.size()][]);
    }

    public static void main(String[] args) {
        int[][] A = {{0,2},{5,10},{13,23},{24,25}};
        int[][] B = {{1,5},{8,12},{15,24},{25,26}};

        int[][] result = intervalIntersection(A, B);

        System.out.println("Intersections:");
        for (int[] r : result) {
            System.out.println(Arrays.toString(r));
        }
    }
}

Key Patterns Summary

| Problem          | Trick             |
| ---------------- | ----------------- |
| Merge intervals  | Sort by start     |
| Remove overlaps  | Sort by end       |
| Meeting conflict | Compare neighbors |
| Intersection     | Two pointers      |

Common Mistakes

• ❌ Forgetting to sort
• ❌ Sorting by wrong value
• ❌ Not handling edge cases (empty input)
• ❌ Modifying shared references incorrectly

🎯 Final Takeaway

Whenever you see:

• Time ranges
• Scheduling
• Conflicts
• Range merging

👉 Think immediately:

“Sort → Compare → Decide”