数据结构与算法之排序详解 一点课堂（多岸学院）

经过前面的知识，咱们已经知道，有序的数据在查找时有极大的性能提高。不少查找都基于有序数据，但并非全部的结构都能像二叉排序树同样，在插入数据时就已经排好序，不少时候每每是无序的数据，须要咱们使用时再进行排序，这就意味着咱们须要寻找高效率的排序算法。接下来，咱们对当下使用较为广泛的几个算法逐一进行分析。这里推荐一个能够查看算法运行动态过程的网站，加深对算法原理的理解。

基础知识 排序定义 假设含有n个记录的序列为{r1. r2, ..., rn}，其相应的关键字分别为{k1, k2, ..., kn}，需肯定1, 2, ..., n的一种排列p1, p2, ..., pn，使其相应的关键字知足kp1≤kp2≤...≤kpn(非递减或非递增) 关系，即便得序列成为一个按关键字有序的序列{rp1, rp2, ..., rpn} ， 这样的操做就称为排序。

稳定性 假设ki=kj( 1≤i≤n, 1≤j≤ n, i≠j ) ，且在排序前的序列中 ri 领先于 rj (即i<j) 。若是排序后 ri 仍领先于 rj，则称所用的排序方法是稳定的；反之，若可能使得排序后的序列中 rj 领先 ri，则称所用的排序方法是不稳定的。

简单来讲，就是对于原数据中相等的数据，排序先后若是相对位置没有改变，就是稳定的。

内排序与外排序 内排序是在排序整个过程当中，待排序的全部记录所有被放置在内存中。外排序是因为排序的记录个数太多，不能同时放置在内存，整个排序过程须要在内外存之间屡次交换数据才能进行。本文先介绍内排序算法，外排序之后再来分析。

冒泡排序 冒泡排序（Bubble Sort）是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，若是反序则交换，直到没有反序的记录为止。

冒泡排序多是咱们最熟悉的排序算法了，它的核心在于两两交换，代码代码：

private void bubbleSort(int[] arr){ int len = arr.length;

for (int i = 0; i < len-1; i++) {
    for (int j=0; j < len-1-i; j++) {
        if(arr[j]>arr[j+1]){
            swap(arr, j, j+1);
        }
    }
}

} 它的最坏时间复杂度是1+2+...+(n-1) = n(n-1)/2，也就是O(n2)，这个复杂度相对仍是比较高的，因此只适合小量数据排序。由于冒泡排序每次遍历后，最后的数据必定是有序的，因此当初始数据部分有序时，还能够对它进行优化。好比数组为{1,0,5,6,7,8,9,10}，当第一次遍历后，数组就是有序的，这时后续的循环遍历都是没有用的，优化后的算法以下：

private void bubbleSort1(int[] arr){ int len = arr.length; boolean flag = false; for (int i = 0; i < len-1; i++) { flag = false; for (int j=0; j < len-1-i; j++) { if(arr[j]>arr[j+1]){ swap(arr, j, j+1); flag = true; } } } } 使用一个flag标记是否有数据交换，冒泡排序若是没有数据交换，则意味着后边的数据必定是有序的，这样一来能够有效地提升冒泡排序的性能。但整体而言，冒泡排序仍是不适合大数据量、数据比较乱的状况。

简单选择排序 选择排序的思想是每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到所有记录排序完毕。简单选择排序就基于此思想，除此以外还有树型选择排序和堆排序也是基于此思想。

简单选择排序法就是经过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第 i (0≤i≤n)个记录交换。

它的实现以下：

private void selectSort(int[] arr){ int len = arr.length; int min; for (int i = 0; i < len; i++) { min = i; for (int j = i+1; j < len; j++) { if(arr[min]>arr[j]){ min = j; } } if(i!=min){ swap(arr,i,min); } } } 整体来看，简单排序算法的最坏时间复杂度也是O(n2)，可是它交换数据的次数明显比冒泡排序要少不少，因此性能也比冒泡排序略优。

直接插入排序 直接插入排序和咱们排序扑克牌的道理一致，就是把新的一张牌插入到已经排好序的牌中，它的基本操做是将一个记录插入到已经排好序的有序表中，从而获得一个新的、记录数增1的有序表。它的代码实现以下：

private void insertSort(int[] arr){ int len = arr.length; int temp; for (int i = 0; i < len; i++) { for (int j = 0; j < i; j++) { if(arr[i]<arr[j]){ temp = arr[i]; // j及之后的记录向后移动一位，而后把当前值存放在j的位置 System.arraycopy(arr,j,arr,j+1,i-j); arr[j] = temp; } } } } 它的最坏时间复杂度依然是O(n2)。

咱们介绍了三种最简单，最容易理解的算法，可是它们的效率也确实较低。在数据量小的时候影响不大，然而现实是咱们更多地要对大量数据进行排序。接下来介绍的几种算法属于改进算法，它们的效率都较为高一些。

希尔排序 简单的排序算法，都须要在数据量少，或者部分有序的状况下，才能发挥较好的性能。可是再大规模的数据均可以拆分红多个小规模的数据，希尔排序的思想就是把大规模的数据拆分红多个小规模数据，而后每部分分别进行直接插入排序，最后再对所有数据进行总体排序。如何拆分就是希尔排序的重点，好比数据是{0, 9, 2, 4, 6, 1}，要将它拆成两部分，若是按照先后拆分，那么进行直接插入排序后结果是{0, 2, 9, 1, 4, 6}，这样排序后对后续总体排序没有帮助。那么希尔排序是如何作的呢？咱们先经过一个简单的数组来演示希尔排序的过程，首先有数组以下： 希尔排序 假设第一次取数据的一半做为间隔值，以后每次减半，咱们把这个值记为inc，那么第一次inc=5，咱们在对应位置前加一条红色虚线表示，以下所示：

接下来咱们就要进行直接插入排序了，前面说过希尔排序不是按照先后区分，而是按照间隔区分的，因此，在进行完这一轮的排序后，咱们要保证如下数据是有序的，以下图所示，不一样颜色表示不一样的子数组，只要保证每一个子数组有序便可：

能够看到，每一个子数组的元素下标间隔都是inc，这就是inc值的意义。根据这一原则，咱们就能够进行直接插入排序了，只须要依次将每一个子数组排好序便可。首先比较0和5位置的值，发现已经有序，无需交换，以下：

而后比较位置1和6，发现数值顺序错误，对它进行交换，以下所示：

接下来再依次比较2和7，3和8，4和9的值，将其排序，最终结果以下所示：

如今，拆分的子数组都已是有序了。接下来，咱们须要合并，咱们把inc的值折半，再进行上述操做，那么inc的位置和拆分的子数组以下所示：

能够看到，每一个子数组的元素下标间隔都和inc值同样，这时子数组只有两个了。咱们来对这两个子数据依次进行直接插入排序，首先对包含位置0的数组进行排序，直接插入排序就是把当前值插入到已有的有序子数组中，因此0位置依然是0，而后把位置2的元素插入，由于1＞0，因此它的位置不变，以下所示：

位置4和6的元素又是最大值，因此也不须要交换，结果以下所示：

接下来位置8，插入后须要和6交换，以下所示：

这样，第一个数组就调整完毕了，接下来调整第二个数组，位置1和3须要交换，以下所示：

接下来调整位置5，由于值3是最小值，应该放在位置1，因此须要把1和3位置的值向后移动，而后再插入，结果以下：

最后位置7和9也按照一样的方式进行，最终结果以下：

如今，咱们再进行合并时就是一个完整的数组了，能够看到，这个数组已是基本有序的了，较小的值基本位于左侧，较大的值基本位于右侧，这比直接进行直接插入排序要好的多。希尔排序的代码以下：

p

rivate void shellSort(int[] arr){
    int len = arr.length;
    int inc = len;
    // 设置间隔值
    for (inc=len/2; inc>0; inc/=2) {
        // i 从inc走到len，j正好能够把全部子数组遍历一次
        // j会先比较每一个子数组的第一个值，再第二个值，这样横向进行遍历
        for (int i = inc; i < len; i++) {
            for (int j = i; j>=inc && arr[j]<arr[j-inc]; j-=inc) {
                swap(arr,j,j-inc);
            }
        }
    }
}

希尔排序整体而言效率比直接插入排序要好，由于它最开始当inc值较大时，数据的移动距离很长，而当inc值小时，由于数据已经大体有序，可使直接插入排序更有效率，这两点是希尔排序高效必备的条件。inc值的选取对希尔排序十分关键，像以上这种折半方式，在某些状况下仍是较慢，可是咱们没有办法找到完美的计算方案使希尔排序最高效，以inc=inc*3+1构建的间隔也是经常使用的一种，示例代码以下：

private void shellSort1(int[] arr) {
    //首先根据数组的长度肯定增量的最大值
    int inc=1;
    // inc * 3 + 1获得增量序列的最大值
    while(inc <= arr.length / 3)
        inc = inc * 3 + 1;
    //进行增量查找和排序
    while(inc>=1){           
        for(int i=inc;i<arr.length;i++){
            for(int j=i;j >= inc && arr[j] < arr[j-inc];j -= inc){
                swap(arr,j,j-inc);
            }
        }
        inc = inc/3;
    } 
}

目前，最高效的希尔排序的时间复杂度能够达到O(n3/2)，相关知识你们能够查阅书籍了解，这里咱们就再也不追究了。

堆排序 堆排序是对简单选择排序的优化，在简单选择排序中，每排序一个数据，都要在剩余所有数据中寻找最小值，可是在这个寻找的过程当中，没有对剩余的数据记录，因此以后的寻找会进行屡次重复操做。堆排序则是会把这些数据记录在堆中，以后的寻找只须要在堆中进行。

堆是具备下列性质的彻底二叉树：每一个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每一个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

根据以上定义，能够肯定，根结点必定是最大（或最小）值。大顶堆和小顶堆示意以下：

若是按照层序遍历的顺序给堆的每一个结点编号：0, 1, ..., (n-1)，那么它必定符合如下条件：

a[i]≤a[2i+1] 且 a[i]≤a[2i+2]，其中0 ≤ i ≤ (n-1)/2，或 a[i]≥a[2i+1] 且 a[i]≥a[2i+2]，其中0 ≤ i ≤ (n-1)/2。

掌握了堆的概念以后，就能够进行堆排序了，以从小到大排序为例，它的过程是先将待排序的数组构建成一个大顶堆，此时，根结点就是最大值，将它放置在数组的结尾，而后将剩余数据从新构建成一个堆，如此循环进行，直到所有有序。

那，咱们如何构建一个大顶堆，又如何进行调整呢？接下来，咱们用一个数组示例，来演示堆排序的过程，假如数组以下：{50, 20, 90, 30, 80, 40, 70, 60, 10}，咱们第一步要作的就是把它看作是一个彻底二叉树层序遍历的结果集，因此它对应的彻底二叉树以下：

咱们要作的，就是把这棵彻底二叉树调整为一个大顶堆结构，按照树的通常处理思路，咱们只须要把每一个子树都调整为大顶堆，就能够把整棵树调整为大顶堆，因此，咱们只须要自下而上，依次把分别以三、二、一、0为根结点的子树调整为大顶堆便可，结点3就是最后一个子树，以后的结点都是叶子结点。

下面先看调整的代码，以下所示：

/**
 * 堆的调整
 * root：子树的根结点位置
 * len：当前排序数组的长度
 */
private void heapAdjust(int[] arr, int root, int len){
    if(len<=0)return;
    int temp;
    // 根结点的值先保存
    temp = arr[root];
    // i是这个结点的左孩子，或者是它孩子的左孩子
    for (int i=2*root+1; i<len; i=2*i+1) {
        if(i<len-1 && arr[i]<arr[i+1]){
            // 寻找到两个孩子的较大者
            i++;
        }
        // 根结点的值比两个孩子都大，就不须要再调整了
        if(temp>=arr[i]){
            break;
        }
        // 把根结点的值记为这个较大的孩子的值
        arr[root] = arr[i];
        // 再向下一级子树遍历
        root=i;
    }
    // 最后把temp的值存放在空置的位置
    arr[root] = temp;
}

按照以上思路，这段代码看起来就比较简单了，那就是寻找到这棵树的最大值，而且每次都选择它的两个孩子中较大的那个进行交换，最终最大值处于根结点。有了调整的代码，咱们就能够把原数组构建成一个大顶堆了，只须要对结点三、二、一、0依次调用调整方法便可。以下所示：

for (int i = (len-2)/2; i>=0; i--) {
    heapAdjust(arr,i,len);
}

这里要说明一下 i 的起点的设置，按照咱们的定义，一个长度为 n 的数组，其下标范围是 0 到(n-1)，若是 n 是奇数，那么最后一个有孩子的结点必定有两个孩子，如上面这棵树的结点3就有两个孩子，若是 n 是偶数，那么最后一个有孩子的结点只有一个左孩子。对于有两个孩子的，咱们用n-1-1，就获得了它左孩子的下标，对于只有一个孩子的，由于 n 是偶数，因此n-1是奇数，n-1-1仍是偶数，能够知道(n-1)/2和(n-2)/2是相等的。综上所述，咱们使用(n-2)/2，就能够获得最后一个有孩子结点的下标。

如今，就能够实现完整的堆排序算法了，只须要每次都把最大值移动到数组最后，而后剩余部分再进行一次调整便可，代码以下所示：

private static void heapSort(int[] arr){
    int len = arr.length;

    // 从最后一个有孩子的结点开始，逐一进行堆的调整
    for (int i = (len-2)/2; i>=0; i--) {
        heapAdjust(arr,i,len);
    }

// 对于一个堆，最大值必定在根结点，也就是在数组位置0，把它换到数组最后，而后对剩余的数据再进行一次堆的调整
for (int i = len-1; i>0; i--) {
    // 把最大值放在数组的最后
    swap(arr,0,i);

    // 剩余的值进行堆的调整
    heapAdjust(arr,0,i);
}

} 堆排序的最坏时间复杂度为O(nlogn)，其中 n 是外层循环，logn是调整内部的for循环，这个for循环和递归相似。由于它对原始数据并不敏感，因此最好、平均和最坏时间复杂度都是O(nlogn)，和O(n2)相比效率高了不少。堆排序由于操做是在原地进行，因此空间复杂度为O(1)。

归并排序 归并排序也利用了彻底二叉树，从而把时间复杂度下降到O(nlogn)，它的思想是一种分而治之的思想，咱们这里以2路归并排序为例，来讲明它的核心原理。

假设初始序列含有 n 个记录，则能够当作是 n 个有序的子序列，每一个子序列的长度为1，而后两两归并，获得n/2个长度为 2 或 1 的有序子序列；再两两归并，...，如此重复，直至获得一个长度为 n 的有序序列为止，这种排序方法称为2路归并排序。

归并排序的原理并不复杂，经过一张图就能够彻底理解它的意图，以下所示，它的过程就是先分后治的分而治之思想的体现：

分，就是把数组拆分红一条一条数据，2路归并就是采用二分法，直到每部分只含一条数据为止。治，就是把数据排序后再合并，从而使得每部分有序，再合并，直到所有有序为止。分的过程可使用递归，这很好实现，代码以下所示：

private void mergeSort(int[] arr, int left, int right){
    if(left<right){
        int mid = (left+right)/2;
        mergeSort(arr,left,mid);
        mergeSort(arr,mid+1,right);
        // 归并操做
        ...
    }
}

接下来就是治的过程，这个过程就是把两个有序数组合并成一个有序数组，以把{2, 8}和{3, 7}合并成{2, 3, 7, 8}为例，首先比较2和3，选择2，以下所示：

接下来应该比较3和8，选择3，以下所示：

接下来比较7和8，选择7以后，只剩下8了，能够确定8及以后（若是有）的全部数据都是比较大且有序的，无需再次比较。根据这个思路，参考代码以下所示：

private void merge(int[] arr, int[] temp, int left, int mid, int right){
    int i = left;
    int j = mid+1;
    int k = 0;
    while(i<=mid && j<=right){
        if(arr[i]<arr[j]){
            temp[k++] = arr[i++];
        }else{
            temp[k++] = arr[j++];
        }
    }

while(i<=mid){
    temp[k++] = arr[i++];
}
while(j<=right){
    temp[k++] = arr[j++];
}

k=0;
while (left<=right) {
    arr[left++] = temp[k++];
}

} 其中temp是事先建立好的数组，由于数组的特殊性，比较操做没法在原数组进行，因此须要在temp数组进行比较后，再将有序结果复制到原数组。最终，归并排序代码以下：

private void mergeSort(int[] arr){
    int[] temp = new int[arr.length];
    mergeSort(arr,temp,0,arr.length-1);
}

private void mergeSort(int[] arr, int[] temp, int left, int right){
    if(left<right){
        int mid = (left+right)/2;
        mergeSort(arr,temp,left,mid);
        mergeSort(arr,temp,mid+1,right);
        merge(arr,temp,left,mid,right);
    }
}

归并排序的时间复杂度是O(nlogn)，而以上使用递归的作法，它的空间复杂度是O(n+logn)，其中 n 是temp数组，logn是递归占用的栈空间。能够看到，递归占用了不菲的空间，那么咱们能不能用非递归的方式实现归并排序呢？答案是确定的，许多递归均可以转为线性操做。归并排序是从单个数据开始的，而数组自己就能够看作是一个一个数据，非递归实现的思路以下：

其中不一样颜色表明不一样的子数组，第一次从原数组进行一次归并后，temp数组中存放的其实就是第二次归并的原始数据，这时只要再从temp数组归并到原数组，就获得了第三次归并的原始数据，重复下去，直到归并完毕。能够看到，只须要一个数组的空间就能够完成所有过程，因此空间复杂度下降到了O(n)。由于篇幅的缘由，代码在文末github连接中，你们能够参考。

快速排序 快速排序：经过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另外一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

从这段定义能够发现，这又是递归能够发挥能力的算法，快速排序的关键在于用来分割的关键字的选择。咱们先从选择每一个子数组最左侧数据为例来实现快速排序，代码以下：

private void quickSort(int[] arr){
    qSort(arr,0,arr.length-1);
}

private void qSort(int[] arr, int low, int high) {
    int pivot;
    if(low<high){
        pivot = partition(arr,low,high);
        qSort(arr,low,pivot-1);
        qSort(arr,pivot+1,high);
    }
}

private int partition(int[] arr, int low, int high) {
    int pivotKey = arr[low];
    while (low<high) {
        while (low<high&&arr[high]>=pivotKey) {
            high--;
        }
        swap(arr,low,high);
        while (low<high&&arr[low]<=pivotKey) {
            low++;
        }
        swap(arr,low,high);
    }
    return low;
}

关键的代码就在partition这个方法中，先选择一个关键字，而后用它左右两侧数据与之对比并调整位置，最后返回这个关键字的地址，再以此分为左右两部分重复此操做。下面，咱们用一个简单的数组来模拟以上操做，以下所示，红色标注的数据就是选择的关键字：

先比较high的值与关键字，若是不须要调整，就向前移动，以下所示：

接下来5和6都比关键字大，直到high的值为1时，交换low与high的值，注意咱们的关键字仍是2，以下所示：

接下来比较low的值与关键字，1比2小，因此low指针后移，以下所示：

接下来8比2大，因此交换low和high的值，以下所示：

交换low和high 接下来直到high指向 7 都再也不进行交换，第一轮排序就结束了，能够看到，low的值依然是以前的关键字。这也是为什么先比较high指针再比较low指针的缘由，也是为什么最终返回low的缘由。接下来只要按照这个规则，就能够把数组排序好。

快速排序最好的时间复杂度为O(nlogn)，也就是每次关键字取值都能刚好把数组平分两部分时的状况，最坏时间复杂度是O(n2)，也就是十分不幸地，每次拆分都分红了一边空一边是剩余所有的两部分。而空间复杂度也跟随着变化，从O(logn)到O(n)。

能够看到，快速排序严重受关键字选择的影响，像以上示例关键字2仅把数组分红了一边长度为一、一边长度为6的两部分，显然不够高效。因而就有了三数取中法，作法是取三个关键字先进行排序，而后用中间的值做为选择的关键字，这样的好处是这个关键字至少不是最大值或最小值，并且颇有可能取到比较接近中间的值，这在大多数状况下都能提升必定的效率。三数取中法只须要在partition中增长如下代码便可：

private static int partition(int[] arr, int low, int high) {
    // 三数取中法,把中间值存放在low中
    int mid = low + (high-low)/2;
    if (arr[low]>arr[high]) {
        swap(arr, low, high);
    }
    if (arr[mid]>arr[high]) {
        swap(arr,mid,high);
    }
    if (arr[low]>arr[mid]) {
        swap(arr,low,mid);
    }

    int pivotKey = arr[low];
    ...
}

固然，三数取中法并不完美，它有可能很高效也可能很低效，这点就须要根据实际状况来合理选择了，甚至有人提出采用九数取中法来进一步提升效率，感兴趣的话能够查阅相关资料进一步研究。接下来咱们对快速排序的其余部分进行优化，在排序过程当中，选取的关键字从最初到最终的位置通过了屡次移动，这是没有必要的，可让它直接到达终点，修改代码以下所示：

private int partition(int[] arr, int low, int high) {
    int pivotKey = arr[low];
// 暂存关键字
int temp = pivotKey;

while (low<high) {
    while (low<high&&arr[high]>=pivotKey) {
        high--;
    }
    arr[low] = arr[high];
    //swap(arr,low,high);
    while (low<high&&arr[low]<=pivotKey) {
        low++;
    }
    arr[high] = arr[low];
    // swap(arr,low,high);
}
// 恢复关键字
arr[low] = temp;
return low;

} 以上优化用复制数据代替了交换数据，从而使性能有必定的提高，能够这样作的缘由是由于每次进行交换的值都包含关键字。除此以外，它的递归部分也能够进行优化，优化后的代码以下所示：

private void qSort(int[] arr, int low, int high) {
    int pivot;
    // 递归
    // if(low<high){
    //     pivot = partition(arr,low,high);
    //     qSort(arr,low,pivot-1);
    //     qSort(arr,pivot+1,high);
    // }
    // 迭代代替递归
    while(low<high){
        pivot = partition(arr,low,high);
        qSort(arr,low,pivot-1);
        low = pivot+1;
    }
}

这个优化就是用循环代替了递归，只是写法上有些不一样，是否真的有优化效果还有待考证。关于递归和循环，也不必定是全部递归都应该使用循环代替，这里有一篇文章我以为分析的不错，你们能够参考一下，连接以下：快速排序的优化和关于递归的问题，说说个人想法。

分配排序 最后，咱们还要讲一个应用场景较少的排序算法，它的时间复杂度能够达到线性阶，也就是O(n)。根据不一样的分配方式，又主要有计数排序、桶排序和基数排序三个算法。

1. 计数排序 计数排序的原理很简单，顾名思义就是对每一个数据计数，而后分配到下标为0-max的数组中，而后对计数进行排列便可。以下所示，桶中存储的是每一个数据出现的次数： 计数 有了计数，就能够获得排好序的数组了，0有0个，1有1个，因此第一个有序值是1，2有一个，因此第二个值是2，依次类推，最后有序数组为{1, 2, 3, 3, 5, 7, 7, 8}。实现代码以下：

   private void countingSort(int[] arr){ int len = arr.length; // 获取最大值 int max = arr[0]; for (int i = 1; i < len; i++) { if(max<arr[i]){ max = arr[i]; } } // 建立max+1个桶，从0-max int[] bucket = new int[max+1]; for (int i = 0; i < len; i++) { // 每获取一个数，就把它放在编号和其一致的桶中 bucket[arr[i]]++; } int j = 0; for (int i = 0, bLen = bucket.length; i < bLen; i++) { // 遍历桶，按顺序恢复每条数据 for (int k = bucket[i]; k > 0; k--) { arr[j++] = i; } } }

由于通常重复数据比较少，因此每一个桶内的值不会很大，它的最好时间复杂度是O(n)。可是它有很严格的使用条件，那就是值是离散的，有穷的，并且数据要紧密，好比有数组{0, 2, 5, ..., 10000}，其中10000与其余数据差距很大，那么就会形成严重的空间浪费，也给遍历增长了难度。可是若是数据能知足这些要求，它的排序速度很是快。

2. 桶排序 桶排序和计数排序相似，只是再也不精确地一个下标对应一个数组，而是取多个区间，好比[0, 10), [10, 20), ...，而后每一个部分再使用如直接插入排序等方法进行排序。这一点和哈希表相似，须要数组和链表结合使用，以下所示： 桶排序 数组的每一位存储的都是链表，对这个链表进行排序比对所有数据排序要好的多，这里就再也不给出代码实现了。

3. 基数排序 基数排序，就是从每一个数的低位开始排序，先排序个位数，再排序十位数、百位数，直至整个数组有序。它的原理以下所示，首先按照个位排序：

根据个位排序的结果，再进行十位数排序，以下所示：

最后再按照百位数排序，以下所示：

4. 总结 分配排序针对整数这种结构，在数据较为均匀，紧密性较好的前提下进行了优化，可使得排序时间复杂度接近O(n)。不过由于它的使用场景较少，且占用空间比较多，所以不常被使用。

总结 除了分配排序这种十分苛刻的排序算法，其余排序的时间复杂度都在O(nlogn)到O(n2)之间。快速排序是当前使用最多的一种排序算法，可是咱们也不能盲目的选择它，而是要针对实际状况选择不一样的算法。一般，当数据量十分小（通常是7-10个）时，会使用直接插入排序来代替其它排序，由于当数据不多时，算法的时间复杂度并不能做为评判算法效率的惟一标准，时间复杂度自己比较粗略，在 n 很小时有可能O(n2)比O(n)还要快，好比n=5，O(n2)算法实际运行次数是n2=25次，而O(n)算法实际运行次数是10n=50次，这时候常数项也会对算法有所影响。

最后，咱们对多种排序的综合性能进行对比，以下表所示：

最后，再对这里的稳定性简单说明一下，对于两两比较的算法必定是稳定的，而存在跳跃比较的算法则是不稳定的，由于两两比较的是相邻值，那么相等的数据不会发生交换，而跳跃比较就没法保证了，因此若是对稳定性要求很高，可能归并排序就是最好的选择。

以上就是常见排序算法的所有解析了，经历了这么多年，还诞生了更多更有趣的排序算法，之后有机会再来一睹为快吧。

QQ讨论群组：984370849 706564342 欢迎加入讨论

想要深刻学习的同窗们能够加入QQ群讨论，有全套资源分享，经验探讨，没错，咱们等着你，分享互相的故事!