这或许是东半球讲十大排序算法最好的一篇文章

做者 | 不应相遇在秋天

冒泡排序

冒泡排序无疑是最为出名的排序算法之一，从序列的一端开始往另外一端冒泡（你能够从左往右冒泡，也能够从右往左冒泡，看心情），依次比较相邻的两个数的大小（究竟是比大仍是比小也看你心情）。

图解冒泡

以 [ 8，2，5，9，7 ] 这组数字来作示例，上图来战：

从左往右依次冒泡，将小的往右移动

首先比较第一个数和第二个数的大小，咱们发现 2 比 8 要小，那么保持原位，不作改动。位置仍是 8，2，5，9，7 。

指针往右移动一格，接着比较：

比较第二个数和第三个数的大小，发现 2 比 5 要小，因此位置交换，交换后数组更新为：[ 8，5，2，9，7 ]。

指针再往右移动一格，继续比较：

比较第三个数和第四个数的大小，发现 2 比 9 要小，因此位置交换，交换后数组更新为：[ 8，5，9，2，7 ]

一样，指针再往右移动，继续比较：

比较第 4 个数和第 5 个数的大小，发现 2 比 7 要小，因此位置交换，交换后数组更新为：[ 8，5，9，7，2 ]

下一步，指针再往右移动，发现已经到底了，则本轮冒泡结束，处于最右边的 2 就是已经排好序的数字。

经过这一轮不断的对比交换，数组中最小的数字移动到了最右边。

接下来继续第二轮冒泡：

因为右边的 2 已是排好序的数字，就再也不参与比较，因此本轮冒泡结束，本轮冒泡最终冒到顶部的数字 5 也归于有序序列中，如今数组已经变化成了[ 8，9，7，5，2 ]。

让咱们开始第三轮冒泡吧！

因为 8 比 7 大，因此位置不变，此时第三轮冒泡也已经结束，第三轮冒泡的最后结果是[ 9，8，7，5，2 ]

紧接着第四轮冒泡：

9 和 8 比，位置不变，即肯定了 8 进入有序序列，那么最后只剩下一个数字 9 ，放在末尾，自此排序结束。

代码实现

public static void sort(int arr[]){
    for( int i = 0 ; i < arr.length - 1 ; i++ ){
        for(int j = 0;j < arr.length - 1 - i ; j++){
            int temp = 0;
            if(arr[j] < arr[j + 1]){
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
复制代码

冒泡的代码仍是至关简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知。

咱们看到嵌套循环，应该立马就能够得出这个算法的时间复杂度为O(n²)。

冒泡优化

冒泡有一个最大的问题就是这种算法无论无论你有序仍是没序，闭着眼睛把你循环比较了再说。

好比我举个数组例子：[ 9，8，7，6，5 ]，一个有序的数组，根本不须要排序，它仍然是双层循环一个很多的把数据遍历干净，这其实就是作了不必作的事情，属于浪费资源。

针对这个问题，咱们能够设定一个临时遍从来标记该数组是否已经有序，若是有序了就不用遍历了。

public static void sort(int arr[]){
    for( int i = 0;i < arr.length - 1 ; i++ ){
        boolean isSort = true;
        for( int j = 0;j < arr.length - 1 - i ; j++ ){
            int temp = 0;
            if(arr[j] < arr[j + 1]){
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                isSort = false;
            }
        }
        if(isSort){
            break;
        }
    }
}
复制代码

选择排序

选择排序的思路是这样的：首先，找到数组中最小的元素，拎出来，将它和数组的第一个元素交换位置，第二步，在剩下的元素中继续寻找最小的元素，拎出来，和数组的第二个元素交换位置，如此循环，直到整个数组排序完成。

至于选大仍是选小，这个都无所谓，你也能够每次选择最大的拎出来排，也能够每次选择最小的拎出来的排，只要你的排序的手段是这种方式，都叫选择排序。

图解选排

咱们仍是以[ 8，2，5，9，7 ]这组数字作例子。

第一次选择，先找到数组中最小的数字 2 ，而后和第一个数字交换位置。（若是第一个数字就是最小值，那么本身和本身交换位置，也能够不作处理，就是一个 if 的事情）

第二次选择，因为数组第一个位置已是有序的，因此只须要查找剩余位置，找到其中最小的数字5，而后和数组第二个位置的元素交换。

第三次选择，找到最小值 7 ，和第三个位置的元素交换位置。

第四次选择，找到最小值8，和第四个位置的元素交换位置。

最后一个到达了数组末尾，没有可对比的元素，结束选择。

如此整个数组就排序完成了。

代码实现

public static void sort(int arr[]){
    for( int i = 0;i < arr.length ; i++ ){
        int min = i;//最小元素的下标
        for(int j = i + 1;j < arr.length ; j++ ){
            if(arr[j] < arr[min]){
                min = j;//找最小值
            }
        }
        //交换位置
        int temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    }
}
复制代码

双层循环，时间复杂度和冒泡如出一辙，都是O(n²)

插入排序

插入排序的思想和咱们打扑克摸牌的时候同样，从牌堆里一张一张摸起来的牌都是乱序的，咱们会把摸起来的牌插入到左手中合适的位置，让左手中的牌时刻保持一个有序的状态。

那若是咱们不是从牌堆里摸牌，而是左手里面初始化就是一堆乱牌呢？ 同样的道理，咱们把牌往手的右边挪一挪，把手的左边空出一点位置来，而后在乱牌中抽一张出来，插入到左边，再抽一张出来，插入到左边，再抽一张，插入到左边，每次插入都插入到左边合适的位置，时刻保持左边的牌是有序的，直到右边的牌抽完，则排序完毕。

图解插排

数组初始化：[ 8，2，5，9，7 ]，咱们把数组中的数据分红两个区域，已排序区域和未排序区域，初始化的时候全部的数据都处在未排序区域中，已排序区域是空。

第一轮，从未排序区域中随机拿出一个数字，既然是随机，那么咱们就获取第一个，而后插入到已排序区域中，已排序区域是空，那么就不作比较，默认自身已是有序的了。（固然了，第一轮在代码中是能够省略的，从下标为1的元素开始便可）

第二轮，继续从未排序区域中拿出一个数，插入到已排序区域中，这个时候要遍历已排序区域中的数字挨个作比较，比大比小取决于你是想升序排仍是想倒序排，这里排升序：

第三轮，排 5 ：

第四轮，排 9 ：

第五轮，排 7

排序结束。

代码实现

public static void sort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; ++i) {
        int value = arr[i];
        int j = 0;//插入的位置
        for (j = i-1; j >= 0; j--) {
            if (arr[j] > value) {
                arr[j+1] = arr[j];//移动数据
            } else {
                break;
            }
        }
        arr[j+1] = value; //插入数据
    }
}
复制代码

从代码里咱们能够看出，若是找到了合适的位置，就不会再进行比较了，就比如牌堆里抽出的一张牌自己就比我手里的牌都小，那么我只须要直接放在末尾就好了，不用一个一个去移动数据腾出位置插入到中间。

因此说，最好状况的时间复杂度是 O(n)，最坏状况的时间复杂度是 O(n²)，然而时间复杂度这个指标看的是最坏的状况，而不是最好的状况，因此插入排序的时间复杂度是 O(n²)。

希尔排序

希尔排序这个名字，来源于它的发明者希尔，也称做“缩小增量排序”，是插入排序的一种更高效的改进版本。

咱们知道，插入排序对于大规模的乱序数组的时候效率是比较慢的，由于它每次只能将数据移动一位，希尔排序为了加快插入的速度，让数据移动的时候能够实现跳跃移动，节省了一部分的时间开支。

图解希尔排序

待排序数组 10 个数据：

假设计算出的排序区间为 4 ，那么咱们第一次比较应该是用第 5 个数据与第 1 个数据相比较。

调换后的数据为[ 7，2，5，9，8，10，1，15，12，3 ]，而后指针右移，第 6 个数据与第 2 个数据相比较。

指针右移，继续比较。

若是交换数据后，发现减去区间获得的位置还存在数据，那么继续比较，好比下面这张图，12 和 8 相比较，原地不动后，指针从 12 跳到 8 身上，继续减去区间发现前面还有一个下标为 0 的数据 7 ，那么 8 和 7 相比较。

比较完以后的效果是 7，8，12 三个数为有序排列。

当最后一个元素比较完以后，咱们会发现大部分值比较大的数据都彷佛调整到数组的中后部分了。

假设整个数组比较长的话，好比有 100 个数据，那么咱们的区间确定是四五十，调整后区间再缩小成一二十还会从新调整一轮，直到最后区间缩小为 1，就是真正的排序来了。

指针右移，继续比较：

重复步骤，便可完成排序，重复的图就很少画了。

咱们能够发现，当区间为 1 的时候，它使用的排序方式就是插入排序。

代码实现

public static void sort(int[] arr) {
    int length = arr.length;
    //区间
    int gap = 1;
    while (gap < length) {
        gap = gap * 3 + 1;
    }
    while (gap > 0) {
        for (int i = gap; i < length; i++) {
            int tmp = arr[i];
            int j = i - gap;
            //跨区间排序
            while (j >= 0 && arr[j] > tmp) {
                arr[j + gap] = arr[j];
                j -= gap;
            }
            arr[j + gap] = tmp;
        }
        gap = gap / 3;
    }
}
复制代码

可能你会问为何区间要以 gap = gap*3 + 1 去计算，其实最优的区间计算方法是没有答案的，这是一个长期未解决的问题，不过差很少都会取在二分之一到三分之一附近。

归并排序

归并字面上的意思是合并，归并算法的核心思想是分治法，就是将一个数组一刀切两半，递归切，直到切成单个元素，而后从新组装合并，单个元素合并成小数组，两个小数组合并成大数组，直到最终合并完成，排序完毕。

图解归并排序

咱们以[ 8，2，5，9，7 ]这组数字来举例

首先，一刀切两半：

再切：

再切

粒度切到最小的时候，就开始归并

数据量设定的比较少，是为了方便图解，数据量为单数，是为了让你看到细节，下面我画了一张更直观的图可能你会更喜欢：

代码实现

咱们上面讲过，归并排序的核心思想是分治，分而治之，将一个大问题分解成无数的小问题进行处理，处理以后再合并，这里咱们采用递归来实现：

public static void sort(int[] arr) {
        int[] tempArr = new int[arr.length];
        sort(arr， tempArr， 0， arr.length-1);
    }

    /**
     * 归并排序
     * @param arr 排序数组
     * @param tempArr 临时存储数组
     * @param startIndex 排序起始位置
     * @param endIndex 排序终止位置
     */
    private static void sort(int[] arr，int[] tempArr，int startIndex，int endIndex){
        if(endIndex <= startIndex){
            return;
        }
        //中部下标
        int middleIndex = startIndex + (endIndex - startIndex) / 2;

        //分解
        sort(arr，tempArr，startIndex，middleIndex);
        sort(arr，tempArr，middleIndex + 1，endIndex);

        //归并
        merge(arr，tempArr，startIndex，middleIndex，endIndex);
    }

    /**
     * 归并
     * @param arr 排序数组
     * @param tempArr 临时存储数组
     * @param startIndex 归并起始位置
     * @param middleIndex 归并中间位置
     * @param endIndex 归并终止位置
     */
    private static void merge(int[] arr， int[] tempArr， int startIndex， int middleIndex， int endIndex) {
        //复制要合并的数据
        for (int s = startIndex; s <= endIndex; s++) {
            tempArr[s] = arr[s];
        }

        int left = startIndex;//左边首位下标
        int right = middleIndex + 1;//右边首位下标
        for (int k = startIndex; k <= endIndex; k++) {
            if(left > middleIndex){
                //若是左边的首位下标大于中部下标，证实左边的数据已经排完了。
                arr[k] = tempArr[right++];
            } else if (right > endIndex){
                //若是右边的首位下标大于了数组长度，证实右边的数据已经排完了。
                arr[k] = tempArr[left++];
            } else if (tempArr[right] < tempArr[left]){
                arr[k] = tempArr[right++];//将右边的首位排入，而后右边的下标指针+1。
            } else {
                arr[k] = tempArr[left++];//将左边的首位排入，而后左边的下标指针+1。
            }
        }
    }
复制代码

咱们能够发现 merge 方法中只有一个 for 循环，直接就能够得出每次合并的时间复杂度为 O(n) ，而分解数组每次对半切割，属于对数时间 O(log n) ，合起来等于 O(log2n) ，也就是说，总的时间复杂度为 O(nlogn) 。

关于空间复杂度，其实大部分人写的归并都是在 merge 方法里面申请临时数组，用临时数组来辅助排序工做，空间复杂度为 O(n)，而我这里作的是原地归并，只在最开始申请了一个临时数组，因此空间复杂度为 O(1)。

快速排序

快速排序的核心思想也是分治法，分而治之。它的实现方式是每次从序列中选出一个基准值，其余数依次和基准值作比较，比基准值大的放右边，比基准值小的放左边，而后再对左边和右边的两组数分别选出一个基准值，进行一样的比较移动，重复步骤，直到最后都变成单个元素，整个数组就成了有序的序列。

图解快排

咱们以[ 8，2，5，0，7，4，6，1 ]这组数字来进行演示

首先，咱们随机选择一个基准值：

与其余元素依次比较，大的放右边，小的放左边：

而后咱们以一样的方式排左边的数据：

继续排 0 和 1 ：

因为只剩下一个数，因此就不用排了，如今的数组序列是下图这个样子：

右边以一样的操做进行，便可排序完成。

单边扫描

快速排序的关键之处在于切分，切分的同时要进行比较和移动，这里介绍一种叫作单边扫描的作法。

咱们随意抽取一个数做为基准值，同时设定一个标记 mark 表明左边序列最右侧的下标位置，固然初始为 0 ，接下来遍历数组，若是元素大于基准值，无操做，继续遍历，若是元素小于基准值，则把 mark + 1 ，再将 mark 所在位置的元素和遍历到的元素交换位置，mark 这个位置存储的是比基准值小的数据，当遍历结束后，将基准值与 mark 所在元素交换位置便可。

代码实现：

public static void sort(int[] arr) {
    sort(arr， 0， arr.length - 1);
}

private static void sort(int[] arr， int startIndex， int endIndex) {
    if (endIndex <= startIndex) {
        return;
    }
    //切分
    int pivotIndex = partitionV2(arr， startIndex， endIndex);
    sort(arr， startIndex， pivotIndex-1);
    sort(arr， pivotIndex+1， endIndex);
}

private static int partition(int[] arr， int startIndex， int endIndex) {
    int pivot = arr[startIndex];//取基准值
    int mark = startIndex;//Mark初始化为起始下标

    for(int i=startIndex+1; i<=endIndex; i++){
        if(arr[i]<pivot){
            //小于基准值 则mark+1，并交换位置。
            mark ++;
            int p = arr[mark];
            arr[mark] = arr[i];
            arr[i] = p;
        }
    }
    //基准值与mark对应元素调换位置
    arr[startIndex] = arr[mark];
    arr[mark] = pivot;
    return mark;
}
复制代码

双边扫描

另外还有一种双边扫描的作法，看起来比较直观：咱们随意抽取一个数做为基准值，而后从数组左右两边进行扫描，先从左往右找到一个大于基准值的元素，将下标指针记录下来，而后转到从右往左扫描，找到一个小于基准值的元素，交换这两个元素的位置，重复步骤，直到左右两个指针相遇，再将基准值与左侧最右边的元素交换。

咱们来看一下实现代码，不一样之处只有 partition 方法：

public static void sort(int[] arr) {
    sort(arr， 0， arr.length - 1);
}

private static void sort(int[] arr， int startIndex， int endIndex) {
    if (endIndex <= startIndex) {
        return;
    }
    //切分
    int pivotIndex = partition(arr， startIndex， endIndex);
    sort(arr， startIndex， pivotIndex-1);
    sort(arr， pivotIndex+1， endIndex);
}


private static int partition(int[] arr， int startIndex， int endIndex) {
    int left = startIndex;
    int right = endIndex;
    int pivot = arr[startIndex];//取第一个元素为基准值

    while (true) {
        //从左往右扫描
        while (arr[left] <= pivot) {
            left++;
            if (left == right) {
                break;
            }
        }

        //从右往左扫描
        while (pivot < arr[right]) {
            right--;
            if (left == right) {
                break;
            }
        }

        //左右指针相遇
        if (left >= right) {
            break;
        }

        //交换左右数据
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }

    //将基准值插入序列
    int temp = arr[startIndex];
    arr[startIndex] = arr[right];
    arr[right] = temp;
    return right;
}
复制代码

极端状况

快速排序的时间复杂度和归并排序同样，O(n log n)，但这是创建在每次切分都能把数组一刀切两半差很少大的前提下，若是出现极端状况，好比排一个有序的序列，如[ 9，8，7，6，5，4，3，2，1 ]，选取基准值 9 ，那么须要切分 n - 1 次才能完成整个快速排序的过程，这种状况下，时间复杂度就退化成了 O(n²)，固然极端状况出现的几率也是比较低的。

因此说，快速排序的时间复杂度是 O(nlogn)，极端状况下会退化成 O(n²)，为了不极端状况的发生，选取基准值应该作到随机选取，或者是打乱一下数组再选取。

另外，快速排序的空间复杂度为 O(1)。

堆排序

堆排序顾名思义，是利用堆这种数据结构来进行排序的算法。

若是你不了解堆这种数据结构，能够查看小吴以前的数据结构系列文章---看动画轻松理解堆

若是你了解堆这种数据结构，你应该知道堆是一种优先队列，两种实现，最大堆和最小堆，因为咱们这里排序按升序排，因此就直接以最大堆来讲吧。

咱们彻底能够把堆（如下全都默认为最大堆）当作一棵彻底二叉树，可是位于堆顶的元素老是整棵树的最大值，每一个子节点的值都比父节点小，因为堆要时刻保持这样的规则特性，因此一旦堆里面的数据发生变化，咱们必须对堆从新进行一次构建。

既然堆顶元素永远都是整棵树中的最大值，那么咱们将数据构建成堆后，只须要从堆顶取元素不就行了吗？ 第一次取的元素，是否取的就是最大值？取完后把堆从新构建一下，而后再取堆顶的元素，是否取的就是第二大的值？ 反复的取，取出来的数据也就是有序的数据。

图解堆排

咱们以[ 8，2，5，9，7，3 ]这组数据来演示。

首先，将数组构建成堆。

既然构建成堆结构了，那么接下来，咱们取出堆顶的数据，也就是数组第一个数 9 ，取法是将数组的第一位和最后一位调换，而后将数组的待排序范围 -1。

如今的待排序数据是[ 3，8，5，2，7 ]，咱们继续将待排序数据构建成堆。

取出堆顶数据，此次就是第一位和倒数第二位交换了，由于待排序的边界已经减 1 。

继续构建堆

从堆顶取出来的数据最终造成一个有序列表，重复的步骤就再也不赘述了，咱们来看一下代码实现。

代码实现

public static void sort(int[] arr) {
    int length = arr.length;
    //构建堆
    buildHeap(arr， length);
    for ( int i = length - 1; i > 0; i-- ) {
        //将堆顶元素与末位元素调换
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        //数组长度-1 隐藏堆尾元素
        length--;
        //将堆顶元素下沉 目的是将最大的元素浮到堆顶来
        sink(arr， 0， length);
    }
}
private static void buildHeap(int[] arr， int length) {
    for (int i = length / 2; i >= 0; i--) {
        sink(arr， i， length);
    }
}

/**
 * 下沉调整
 * @param arr 数组
 * @param index 调整位置
 * @param length 数组范围
 */
private static void sink(int[] arr， int index， int length) {
    int leftChild = 2 * index + 1;//左子节点下标
    int rightChild = 2 * index + 2;//右子节点下标
    int present = index;//要调整的节点下标

    //下沉左边
    if (leftChild < length && arr[leftChild] > arr[present]) {
        present = leftChild;
    }

    //下沉右边
    if (rightChild < length && arr[rightChild] > arr[present]) {
        present = rightChild;
    }

    //若是下标不相等 证实调换过了
    if (present != index) {
        //交换值
        int temp = arr[index];
        arr[index] = arr[present];
        arr[present] = temp;

        //继续下沉
        sink(arr， present， length);
    }
}

复制代码

堆排序和快速排序的时间复杂度都同样是 O(nlogn)。

计数排序

计数排序是一种非基于比较的排序算法，咱们以前介绍的各类排序算法几乎都是基于元素之间的比较来进行排序的，计数排序的时间复杂度为 O(n + m )，m 指的是数据量，说的简单点，计数排序算法的时间复杂度约等于 O(n)，快于任何比较型的排序算法。

图解计数

如下以[ 3，5，8，2，5，4 ]这组数字来演示。

首先，咱们找到这组数字中最大的数，也就是 8，建立一个最大下标为 8 的空数组 arr 。

遍历数据，将数据的出现次数填入arr中对应的下标位置中。

遍历 arr ，将数据依次取出便可。

代码实现

public static void sort(int[] arr) {
    //找出数组中的最大值
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    //初始化计数数组
    int[] countArr = new int[max + 1];

    //计数
    for (int i = 0; i < arr.length; i++) {
        countArr[arr[i]]++;
        arr[i] = 0;
    }
    
    //排序
    int index = 0;
    for (int i = 0; i < countArr.length; i++) {
        if (countArr[i] > 0) {
            arr[index++] = i;
        }
    }
}

复制代码

稳定排序

有一个需求就是当对成绩进行排名次的时候，如何在原来排前面的人，排序后仍是处于相同成绩的人的前面。

解题的思路是对 countArr 计数数组进行一个变形，变来和名次挂钩，咱们知道 countArr 存放的是分数的出现次数，那么其实咱们能够算出每一个分数的最大名次，就是将 countArr 中的每一个元素顺序求和。

以下图：

变形以后是什么意思呢？

咱们把原数组[ 2，5，8，2，5，4 ]中的数据依次拿来去 countArr 去找，你会发现 3 这个数在 countArr[3] 中的值是 2 ，表明着排名第二名，（由于第一名是最小的 2，对吧？），5 这个数在 countArr[5] 中的值是 5 ，为何是 5 呢？咱们来数数，排序后的数组应该是[ 2，3，4，5，5，8 ]，5 的排名是第五名，那 4 的排名是第几名呢？对应 countArr[4] 的值是 3 ，第三名，5 的排名是第五名是由于 5 这个数有两个，天然占据了第 4 名和第 5 名。

因此咱们取排名的时候应该特别注意，原数组中的数据要从右往左取，从 countArr 取出排名后要把 countArr 中的排名减 1 ，以便于再次取重复数据的时候排名往前一位。

对应代码实现：

public static void sort(int[] arr) {
    //找出数组中的最大值
    int max = arr[0];
    for (int i = 1; i < arr.length; ++i) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }

    //初始化计数数组
    int[] countArr = new int[max + 1];

    //计数
    for (int i = 0; i < arr.length; ++i) {
        countArr[arr[i]]++;
    }

    //顺序累加
    for (int i = 1; i < max + 1; ++i) {
        countArr[i] = countArr[i-1] + countArr[i];
    }

    //排序后的数组
    int[] sortedArr = new int[arr.length];
    
    //排序
    for (int i = arr.length - 1; i >= 0; --i) {
        sortedArr[countArr[arr[i]]-1] = arr[i];
        countArr[arr[i]]--;
    }

    //将排序后的数据拷贝到原数组
    for (int i = 0; i < arr.length; ++i) {
        arr[i] = sortedArr[i];
    }
}


复制代码

计数局限性

计数排序的毛病不少，咱们来找找 bug 。

若是我要排的数据里有 0 呢？ int[] 初始化内容全是 0 ，排毛线。

若是我要排的数据范围比较大呢？好比[ 1，9999 ]，我排两个数你要建立一个 int[10000] 的数组来计数？

对于第一个 bug ，咱们可使用偏移量来解决，好比我要排[ -1，0，-3 ]这组数字，这个简单，我全给大家加 10 来计数，变成[ 9，10，7 ]计完数后写回原数组时再减 10。不过有可能也会踩到坑，万一你数组里刚好有一个 -10，你加上 10 后又变 0 了，排毛线。

对于第二个 bug ，确实解决不了，若是是[ 9998，9999 ]这种虽然值大可是相差范围不大的数据咱们也可使用偏移量解决，好比这两个数据，我减掉 9997 后只须要申请一个 int[3] 的数组就能够进行计数。

因而可知，计数排序只适用于正整数而且取值范围相差不大的数组排序使用，它的排序的速度是很是可观的。

桶排序

桶排序能够当作是计数排序的升级版，它将要排的数据分到多个有序的桶里，每一个桶里的数据再单独排序，再把每一个桶的数据依次取出，便可完成排序。

图解桶排序

咱们拿一组计数排序啃不掉的数据 [ 500，6123，1700，10，9999 ] 来举例。

第一步，咱们建立 10 个桶，分别来装 0-1000 、1000-2000 、 2000-3000 、 3000-4000 、 4000-5000 、5000-6000、 6000-7000 、7000-8000 、8000-9000 区间的数据。

第二步，遍历原数组，对号入桶。

第三步，对桶中的数据进行单独排序，只有第一个桶中的数量大于 1 ，显然只须要排第一个桶。

最后，依次将桶中的数据取出，排序完成。

代码实现

这个桶排序乍一看好像挺简单的，可是要敲代码就须要考虑几个问题了。

桶这个东西怎么表示？

怎么肯定桶的数量？

桶内排序用什么方法排？

代码以下：

public static void sort(int[] arr){
    //最大最小值
    int max = arr[0];
    int min = arr[0];
    int length = arr.length;

    for(int i=1; i<length; i++) {
        if(arr[i] > max) {
            max = arr[i];
        } else if(arr[i] < min) {
            min = arr[i];
        }
    }

    //最大值和最小值的差
    int diff = max - min;

    //桶列表
    ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();
    for(int i = 0; i < length; i++){
        bucketList.add(new ArrayList<>());
    }

    //每一个桶的存数区间
    float section = (float) diff / (float) (length - 1);

    //数据入桶
    for(int i = 0; i < length; i++){
        //当前数除以区间得出存放桶的位置 减1后得出桶的下标
        int num = (int) (arr[i] / section) - 1;
        if(num < 0){
            num = 0;
        }
        bucketList.get(num).add(arr[i]);
    }

    //桶内排序
    for(int i = 0; i < bucketList.size(); i++){
        //jdk的排序速度固然信得过
        Collections.sort(bucketList.get(i));
    }

    //写入原数组
    int index = 0;
    for(ArrayList<Integer> arrayList : bucketList){
        for(int value : arrayList){
            arr[index] = value;
            index++;
        }
    }
}

复制代码

桶固然是一个能够存放数据的集合，我这里使用 arrayList ，若是你使用 LinkedList 那其实也是没有问题的。

桶的数量我认为设置为原数组的长度是合理的，由于理想状况下每一个数据装一个桶。

数据入桶的映射算法实际上是一个开放性问题，我认可我这里写的方案并不佳，由于我测试过不一样的数据集合来排序，若是你有什么更好的方案或想法，欢迎留言讨论。

桶内排序为了方便起见使用了当前语言提供的排序方法，若是对于稳定排序有所要求，能够选择使用自定义的排序算法。

桶排序的思考及其应用

在额外空间充足的状况下，尽可能增大桶的数量，极限状况下每一个桶只有一个数据时，或者是每只桶只装一个值时，彻底避开了桶内排序的操做，桶排序的最好时间复杂度就可以达到 O(n)。

好比高考总分 750 分，全国几百万人，咱们只须要建立 751 个桶，循环一遍挨个扔进去，排序速度是毫秒级。

可是若是数据通过桶的划分以后，桶与桶的数据分布极不均匀，有些数据很是多，有些数据很是少，好比[ 8，2，9，10，1，23，53，22，12，9000 ]这十个数据，咱们分红十个桶装，结果发现第一个桶装了 9 个数据，这是很是影响效率的状况，会使时间复杂度降低到 O(nlogn)，解决办法是咱们每次桶内排序时判断一下数据量，若是桶里的数据量过大，那么应该在桶里面回调自身再进行一次桶排序。

基数排序

基数排序是一种非比较型整数排序算法，其原理是将数据按位数切割成不一样的数字，而后按每一个位数分别比较。 假设说，咱们要对 100 万个手机号码进行排序，应该选择什么排序算法呢？排的快的有归并、快排时间复杂度是 O(nlogn)，计数排序和桶排序虽然更快一些，可是手机号码位数是11位，那得须要多少桶？内存条表示不服。

这个时候，咱们使用基数排序是最好的选择。

图解基排

咱们以[ 892， 846， 821， 199， 810，700 ]这组数字来作例子演示。

首先，建立十个桶，用来辅助排序。

先排个位数，根据个位数的值将数据放到对应下标值的桶中。

排完后，咱们将桶中的数据依次取出。

那么接下来，咱们排十位数。

最后，排百位数。

排序完成。

代码实现

基数排序能够当作桶排序的扩展，也是用桶来辅助排序，代码以下：

public static void sort(int[] arr){
    int length = arr.length;

    //最大值
    int max = arr[0];
    for(int i = 0;i < length;i++){
        if(arr[i] > max){
            max = arr[i];
        }
    }
    //当前排序位置
    int location = 1;

    //桶列表
    ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();

    //长度为10 装入余数0-9的数据
    for(int i = 0; i < 10; i++){
        bucketList.add(new ArrayList());
    }

    while(true)
    {
        //判断是否排完
        int dd = (int)Math.pow(10，(location - 1));
        if(max < dd){
            break;
        }

        //数据入桶
        for(int i = 0; i < length; i++)
        {
            //计算余数 放入相应的桶
            int number = ((arr[i] / dd) % 10);
            bucketList.get(number).add(arr[i]);
        }

        //写回数组
        int nn = 0;
        for (int i=0;i<10;i++){
            int size = bucketList.get(i).size();
            for(int ii = 0;ii < size;ii ++){
                arr[nn++] = bucketList.get(i).get(ii);
            }
            bucketList.get(i).clear();
        }
        location++;
    }
}
复制代码

其实它的思想很简单，无论你的数字有多大，按照一位一位的排，0 - 9 最多也就十个桶：先按权重小的位置排序，而后按权重大的位置排序。

固然，若是你有需求，也能够选择从高位往低位排。

总结

感谢你看到了这里，但愿看完这篇文章能让你清晰的理解平时最经常使用的十大排序算法。