十大经典排序算法——桶排序 （Java、JavaScript、PHP语言实现）

十大经典排序算法之——桶排序

本文主要介绍十大经典排序算法中的“桶排序”，并附上桶排序算法的Java、JavaScript、PHP语言实现。

1、十大经典排序算法介绍

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

2、十大经典排序算法比较

注：关于时间复杂度

1.平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。
2.线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序。
3.O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。希尔排序。
4.线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

注：关于稳定性

稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

相关名词解释：n：数据规模，k：“桶”的个数，In-place：占用常数内存，不占用额外内存，Out-place：占用额外内存。

3、细说桶排序

3.1 桶排序介绍

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

1.在额外空间充足的情况下，尽量增大桶的数量

2.使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

3.2 桶排序什么时候最快、最慢 ？

1.什么时候最快 ?

当输入的数据可以均匀的分配到每一个桶中时最快。

2.什么时候最慢 ?

当输入的数据被分配到了同一个桶中时最慢。

3.3 计数排序算法的代码实现

3.3.1 Java实现

public class BucketSort implements IArraySort {

    private static final InsertSort insertSort = new InsertSort();

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        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;
    }

    /**
     * 自动扩容，并保存数据
     *
     * @param arr
     * @param value
     */
    private int[] arrAppend(int[] arr, int value) {
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = value;
        return arr;
    }

}

3.3.2 JavaScript实现

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;            // 设置桶的默认数量为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;
}

3.3.3 PHP实现

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;
}

4、桶排序总结

桶排序：利用映射函数把待排序数据分配到不同的“桶”中，实现排序，是稳定的排序算法。

5、其他排序算法

这里给出十大经典排序算法中的其他经典排序算法文章供大家参考、学习

冒泡排序
选择排序
插入排序
希尔排序
归并排序
快速排序
计数排序
堆排序

如有问题、想法，欢迎在此博客下面留言讨论