桶排序

public static void bucketSort(int[] arr,int bucketSize){
    if(arr.length < 2) return;
    // 数组最小值
    int minValue = arr[0];
    // 数组最大值
    int maxValue = arr[1];
    for(int i = 0;i<arr.length;i++){
        if(arr[i] < minValue){
            minValue = arr[i];
        }else if(arr[i] > maxValue){
            maxValue = arr[i];
        }
    }
	// 桶数量
    int bucketCount = (maxValue - minValue) / bucketSize + 1;
    int[][] buckets = new int[bucketCount][bucketSize];
    int[] indexArr = new int[bucketCount];
	// 将数组中值分配到各个桶里
    for(int i = 0;i<arr.length;i++){
        int bucketIndex = (arr[i] - minValue) / bucketSize;
        if(indexArr[bucketIndex] == buckets[bucketIndex].length){
            ensureCapacity(buckets,bucketIndex);
        }
        buckets[bucketIndex][indexArr[bucketIndex]++] = arr[i];
    }
    // 对每个桶进行排序，这里使用了快速排序
    int k = 0;
    for(int i = 0;i<buckets.length;i++){
        if(indexArr[i] == 0){
            continue;
        }
        quickSort(buckets[i],0,indexArr[i] - 1);
        for(int j = 0;j<indexArr[i];j++){
            arr[k++] = buckets[i][j];
        }
    }

}

private static void quickSort(int[] arr, int p, int r) {
    if(p>=r) return;
    int q = partition(arr,p,r);
    quickSort(arr,p,q-1);
    quickSort(arr,q+1,r);
}

private static int partition(int[] arr, int p, int r) {
    int pivot = arr[r];
    int i = p;
    for(int j = p;j<r;j++){
        if(arr[j] < pivot){
            if(j==i){
                i++;
            }else {
                int tmp = arr[i];
                arr[i++] = arr[j];
                arr[j] = tmp;
            }
        }
    }
    int tmp = arr[i];
    arr[i] = arr[r];
    arr[r] = tmp;
    return i;
}

private static void ensureCapacity(int[][] buckets, int bucketIndex) {
    int[] tmpArr = buckets[bucketIndex];
    int[] newArr = new int[tmpArr.length * 2];
    for(int j = 0;j<tmpArr.length;j++){
        newArr[j] = tmpArr[j];
    }
    buckets[bucketIndex] = newArr;
}