Maximum Gap

Maximum Gap - Problem

Given an integer array nums, return the maximum difference between two successive elements in its sorted form.

If the array contains less than two elements, return 0.

You must write an algorithm that runs in linear time and uses linear extra space.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Sorted array is [1,3,6,9]. Gaps are: 3-1=2, 6-3=3, 9-6=3. Maximum gap is 3.

Example 2 — Larger Gap at End

$ Input: nums = [10]

› Output: 0

💡 Note: Array has less than 2 elements, so return 0.

Example 3 — Multiple Large Gaps

$ Input: nums = [1,10000000]

› Output: 9999999

💡 Note: Only two elements, so maximum gap is 10000000 - 1 = 9999999.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that the maximum gap must be at least (max-min)/(n-1), so we can use bucket sort to achieve linear time. The optimal approach uses buckets where the maximum gap occurs between buckets, not within them. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Bucket Sort Approach	O(n)	O(n)	Use buckets to achieve linear time by skipping unnecessary comparisons
Sort and Compare	O(n log n)	O(1)	Sort the array and find maximum difference between consecutive elements

Bucket Sort Approach — Algorithm Steps

Calculate bucket size as (max-min)/(n-1)
Place elements into appropriate buckets
Find maximum gap between non-empty buckets

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Buckets

Determine bucket size and distribute elements

Fill Buckets

Store min and max for each bucket

Check Gaps

Maximum gap occurs between buckets only

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    if (numsSize < 2) return 0;
    
    int minVal = nums[0], maxVal = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    if (maxVal == minVal) return 0;
    
    // Calculate bucket size
    int bucketSize = (maxVal - minVal) / (numsSize - 1);
    if (bucketSize == 0) bucketSize = 1;
    int bucketCount = (maxVal - minVal) / bucketSize + 1;
    
    // Initialize buckets
    int* bucketMin = malloc(bucketCount * sizeof(int));
    int* bucketMax = malloc(bucketCount * sizeof(int));
    for (int i = 0; i < bucketCount; i++) {
        bucketMin[i] = INT_MAX;
        bucketMax[i] = INT_MIN;
    }
    
    // Place elements in buckets
    for (int i = 0; i < numsSize; i++) {
        int idx = (nums[i] - minVal) / bucketSize;
        if (nums[i] < bucketMin[idx]) bucketMin[idx] = nums[i];
        if (nums[i] > bucketMax[idx]) bucketMax[idx] = nums[i];
    }
    
    // Find maximum gap between buckets
    int maxGap = 0;
    int prevMax = minVal;
    
    for (int i = 0; i < bucketCount; i++) {
        if (bucketMin[i] == INT_MAX) continue;
        int gap = bucketMin[i] - prevMax;
        if (gap > maxGap) maxGap = gap;
        prevMax = bucketMax[i];
    }
    
    free(bucketMin);
    free(bucketMax);
    return maxGap;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(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 gaps

✓ Linear Growth

Space Complexity

O(n)

Bucket arrays store min and max values for each bucket

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Constraints

Visualization

Related Problems

Common Approaches

Bucket Sort Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler