Maximum Gap - Practice Coding Problems

Maximum Gap - Problem

Find the Maximum Gap in Sorted Elements

You're given an unsorted integer array nums, and your mission is to find the maximum difference between two successive elements when the array is sorted in ascending order.

🎯 The Challenge: You must solve this in linear time O(n) and use only linear extra space O(n)!

📝 Special Cases:
• If the array has fewer than 2 elements, return 0
• The array may contain duplicates

Example: For [3, 6, 9, 1], when sorted becomes [1, 3, 6, 9], the successive differences are [2, 3, 3], so the maximum gap is 3.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3, 6, 9, 1]

› Output: 3

💡 Note: When sorted, the array becomes [1, 3, 6, 9]. The successive differences are [2, 3, 3], and the maximum is 3.

example_2.py — All Same Elements

$ Input: nums = [10]

› Output: 0

💡 Note: The array has only one element, so there are no successive pairs to compare.

example_3.py — Large Gap

$ Input: nums = [1, 1000000]

› Output: 999999

💡 Note: When sorted, it's still [1, 1000000]. The gap between successive elements is 1000000 - 1 = 999999.

Visualization

Tap to expand

Understanding the Visualization

Find Range

Determine the range from minimum to maximum value

Create Buckets

Create n-1 buckets to distribute n numbers

Fill Buckets

Place numbers in appropriate buckets, storing only min/max per bucket

Find Max Gap

The answer is the maximum gap between consecutive non-empty buckets

Key Takeaway

🎯 Key Insight: By using the pigeonhole principle with n-1 buckets for n numbers, we guarantee that the maximum gap occurs between buckets, not within them. This allows us to solve the problem in linear time!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find min/max, single pass to fill buckets, single pass to find max gap

✓ Linear Growth

Space Complexity

O(n)

Need space for n-1 buckets, each storing min and max values

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Must solve in O(n) time and O(n) space

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Facebook 6

The optimal solution uses bucket sort with the pigeonhole principle. By creating n-1 buckets for n elements, we ensure the maximum gap must occur between buckets, not within them. This achieves O(n) time and O(n) space complexity as required.

Common Approaches

Approach	Time	Space	Notes
✓ Bucket Sort Approach (Linear Time)	O(n)	O(n)	Use bucket sort with pigeonhole principle to achieve O(n) time complexity
Brute Force (Sort and Compare)	O(n log n)	O(1)	Sort the array then find maximum difference between consecutive elements

Bucket Sort Approach (Linear Time) — Algorithm Steps

Handle edge cases (less than 2 elements)
Find minimum and maximum values in the array
Calculate bucket size using (max-min)/(n-1)
Create n-1 buckets, each storing min and max values
Distribute numbers into appropriate buckets
Find maximum gap between consecutive non-empty buckets

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Buckets

Create n-1 buckets based on range and pigeonhole principle

Distribute Elements

Place each element into appropriate bucket

Store Min/Max

Each bucket only stores minimum and maximum values

Find Max Gap

Maximum gap occurs between consecutive non-empty buckets

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

typedef struct {
    int min;
    int max;
    int empty;
} Bucket;

int maximumGap(int* nums, int numsSize) {
    if (numsSize < 2) {
        return 0;
    }
    
    int minVal = nums[0], maxVal = nums[0];
    
    // Find min and max
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    // If all elements are the same
    if (minVal == maxVal) {
        return 0;
    }
    
    // Calculate bucket size
    int bucketSize = (maxVal - minVal) / (numsSize - 1);
    if (bucketSize == 0) bucketSize = 1;
    
    int bucketCount = (maxVal - minVal) / bucketSize + 1;
    
    // Initialize buckets
    Bucket* buckets = (Bucket*)malloc(bucketCount * sizeof(Bucket));
    for (int i = 0; i < bucketCount; i++) {
        buckets[i].min = INT_MAX;
        buckets[i].max = INT_MIN;
        buckets[i].empty = 1;
    }
    
    // Place numbers in buckets
    for (int i = 0; i < numsSize; i++) {
        int bucketIdx = (nums[i] - minVal) / bucketSize;
        if (buckets[bucketIdx].empty) {
            buckets[bucketIdx].min = nums[i];
            buckets[bucketIdx].max = nums[i];
            buckets[bucketIdx].empty = 0;
        } else {
            if (nums[i] < buckets[bucketIdx].min) {
                buckets[bucketIdx].min = nums[i];
            }
            if (nums[i] > buckets[bucketIdx].max) {
                buckets[bucketIdx].max = nums[i];
            }
        }
    }
    
    // Find maximum gap
    int maxGap = 0;
    int prevMax = minVal;
    
    for (int i = 0; i < bucketCount; i++) {
        if (!buckets[i].empty) {
            int gap = buckets[i].min - prevMax;
            if (gap > maxGap) {
                maxGap = gap;
            }
            prevMax = buckets[i].max;
        }
    }
    
    free(buckets);
    return maxGap;
}

int main() {
    int nums[] = {3, 6, 9, 1};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", maximumGap(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find min/max, single pass to fill buckets, single pass to find max gap

✓ Linear Growth

Space Complexity

O(n)

Need space for n-1 buckets, each storing min and max values

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Must solve in O(n) time and O(n) space

98.4K Views

Medium Frequency

~25 min Avg. Time

2.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bucket Sort Approach (Linear Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler