Maximum Gap

Given an unsorted array, find the maximum difference between the successive elements in its sorted form.

Try to solve it in linear time/space.

Return 0 if the array contains less than 2 elements.

You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.

解法1： 时间O(nlogn), 空间O(1). 排序在比较。

public class Solution {
    public int maximumGap(int[] num) {
        if(num == null || num.length < 2) return 0;
        Arrays.sort(num);
        int result = 0;
        for(int i = 0; i < num.length - 1; i ++){
            result = Math.max(result, num[i + 1] - num[i]);
        }
        return result;
    }
}

 这一题有两个解法： radix sort 或者 buket sort.

radix sort的话 可以based on 很多形式进行。 如二进制，十进制，或者256.

试着用二进制写了一个：

public class Solution {
    public int maximumGap(int[] num) {
        if(num == null || num.length < 2) return 0;
        radixSort(num);
        int max = 0;
        for(int i = 1; i < num.length; i ++){
            max = Math.max(max, num[i] - num[i - 1]);
        }
        return max;
    }
    
    private void radixSort(int[] num){
        if(num == null || num.length == 0) return;
        int[] ones = new int[num.length];
        int[] zeros= new int[num.length];
        int leno = 0, lenz = 0, len = 0;
        for(int i = 0; i < 32; i ++){//this is an Integer
            len = 0;
            lenz = 0;
            leno = 0;
            for(int j = 0; j < num.length; j ++){//sort based on current bit position
                if(((num[j] >> i) & 1) == 1){
                    ones[leno++] = num[j];
                }else{
                    zeros[lenz++] = num[j];
                }
            }
            for(int j = 0; j < lenz; j ++){//put back to num[]
                num[len ++] = zeros[j];
                zeros[j] = 0;//clean up zero array
            }
            for(int j = 0; j < leno; j ++){
                num[len ++] = ones[j];
                ones[j] = 0;//clean up one array
            }
        }
    }
}

如果用bucket sort，那么涉及到一定数学的证明：

官方版（桶排序）：

假设有N个元素A到B。

如果有n + 1 个桶，则一定有一个是空的。 且这个桶两边的元素的差一定比同一个桶内元素的差要大。

故要生成一个n + 1 的buckets。

则每一个的间隔是 (max - min) / num.length.

Let Max be the largest number in A and Min be the smallest number in A. Let d = (Max –Min)/(n). We divide all numbers in [Min, Max] into n-1 buckets, where k-th bucket contains all numbers in [Min + (k-1)d, Min + kd). This can be done by putting element A[i] into the k-th bucket if floor((A[i]-Min)/n) = k. Since there are n-2 numbers that are not equal Min or Max and there are n-1 buckets, at least one of the buckets are empty. That is, any two numbers that are in the same bucket cannot be the answer. Thus, we only need to store the largest number and the smallest number in each bucket. Then, we can scan the buckets sequentially and get a sorted list. The maximum difference between two consecutive elements is the answer.

public class Solution {
    class Bucket{
        int min;
        int max;
        public Bucket(){
            this.min = Integer.MAX_VALUE;
            this.max = Integer.MIN_VALUE;
        }
    }
    
    public int maximumGap(int[] num) {
        if(num == null || num.length < 2) return 0;
        int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
        for(int i = 0; i < num.length; i ++){
            min = Math.min(min, num[i]);
            max = Math.max(max, num[i]);
        }
        Bucket[] buckets = new Bucket[num.length + 1];
        for(int i = 0; i < buckets.length; i ++){
            buckets[i] = new Bucket();
        }
        double interval = (double)num.length / (max - min);//put num.length elements into num.length + 1 buckets
        for(int i = 0; i < num.length; i ++){
            int pos = (int)((num[i] - min) * interval);
            if(buckets[pos].min > num[i]) buckets[pos].min = num[i];
            if(buckets[pos].max < num[i]) buckets[pos].max = num[i];
        }
        int result = 0;
        int pre = buckets[0].max;
        for(int i = 1; i < buckets.length; i ++){//be care there can be empty buckets
            if(buckets[i].min != Integer.MAX_VALUE){
                result = Math.max(result, buckets[i].min - pre);
                pre = buckets[i].max;
            }
        }
        return result;
    }
}