桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效,我们需要做到这两点:
- 在额外空间充足的情况下,尽量增大桶的数量
- 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
同时,对于桶中元素的排序,选择何种比较排序算法对于性能的影响至关重要。
1. 什么时候最快
当输入的数据可以均匀的分配到每一个桶中。
2. 什么时候最慢
当输入的数据被分配到了同一个桶中。
3. JavaScript 代码实现
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
| function bucketSort(arr, bucketSize) { if (arr.length === 0) { return arr; }
var i; var minValue = arr[0]; var maxValue = arr[0]; for (i = 1; i < arr.length; i++) { if (arr[i] < minValue) { minValue = arr[i]; } else if (arr[i] > maxValue) { maxValue = arr[i]; } }
var DEFAULT_BUCKET_SIZE = 5; bucketSize = bucketSize || DEFAULT_BUCKET_SIZE; var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1; var buckets = new Array(bucketCount); for (i = 0; i < buckets.length; i++) { buckets[i] = []; }
for (i = 0; i < arr.length; i++) { buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]); }
arr.length = 0; for (i = 0; i < buckets.length; i++) { insertionSort(buckets[i]); for (var j = 0; j < buckets[i].length; j++) { arr.push(buckets[i][j]); } }
return arr; }
|
4. Java 代码实现
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
| public class BucketSort implements IArraySort {
private static final InsertSort insertSort = new InsertSort();
@Override public int[] sort(int[] sourceArray) throws Exception { int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return bucketSort(arr, 5); }
private int[] bucketSort(int[] arr, int bucketSize) throws Exception { if (arr.length == 0) { return arr; }
int minValue = arr[0]; int maxValue = arr[0]; for (int value : arr) { if (value < minValue) { minValue = value; } else if (value > maxValue) { maxValue = value; } }
int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1; int[][] buckets = new int[bucketCount][0];
for (int i = 0; i < arr.length; i++) { int index = (int) Math.floor((arr[i] - minValue) / bucketSize); buckets[index] = arrAppend(buckets[index], arr[i]); }
int arrIndex = 0; for (int[] bucket : buckets) { if (bucket.length <= 0) { continue; } bucket = insertSort.sort(bucket); for (int value : bucket) { arr[arrIndex++] = value; } }
return arr; }
private int[] arrAppend(int[] arr, int value) { arr = Arrays.copyOf(arr, arr.length + 1); arr[arr.length - 1] = value; return arr; }
}
|
5. PHP 代码实现
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
| function bucketSort($arr, $bucketSize = 5) { if (count($arr) === 0) { return $arr; }
$minValue = $arr[0]; $maxValue = $arr[0]; for ($i = 1; $i < count($arr); $i++) { if ($arr[$i] < $minValue) { $minValue = $arr[$i]; } else if ($arr[$i] > $maxValue) { $maxValue = $arr[$i]; } }
$bucketCount = floor(($maxValue - $minValue) / $bucketSize) + 1; $buckets = array(); for ($i = 0; $i < count($buckets); $i++) { $buckets[$i] = []; }
for ($i = 0; $i < count($arr); $i++) { $buckets[floor(($arr[$i] - $minValue) / $bucketSize)][] = $arr[$i]; }
$arr = array(); for ($i = 0; $i < count($buckets); $i++) { $bucketTmp = $buckets[$i]; sort($bucketTmp); for ($j = 0; $j < count($bucketTmp); $j++) { $arr[] = $bucketTmp[$j]; } }
return $arr; }
|