十大经典排序算法(C++、Java实现)动图演示及代码解析-冒泡排序、选择排序、插入排序、快速排序、堆排序、希尔排序、归并排序、计数排序、桶排序、基数排序

和我的LeetCode系列源码放到一起。做IT行业，不管是测试、开发、运维等等，或简单或复杂的算法是必不可少的，也是大家面试工作中的必要环节，这个专栏开始和大家一起来研究著名的LeetCode，里边有上千种最常见的算法，面试工作出现几率很高，值得掌握研究，每次完成博客更新我会同步更新我的个人Github上的代码，每个算法都可以直接运行调试以供掌握，GitHub地址：https://github.com/cuiguangwei/LeetCodeProject.git，欢迎大家一起学习讨论进步！

前言

　　查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有面试官要求现场写出这两种排序的代码。对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。面试官对于这些排序可能会要求比较各自的优劣、各种算法的思想及其使用场景。还有要会分析算法的时间和空间复杂度。通常查找和排序算法的考察是面试的开始，如果这些问题回答不好，估计面试官都没有继续面试下去的兴趣都没了。所以想开个好头就要把常见的排序算法思想及其特点要熟练掌握，有必要时要熟练写出代码。

　　接下来我们就分析一下常见的排序算法及其使用场景。

十种常见排序算法可以分为两大类：

（选泡插，快归堆希统计基）

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。

非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 

复杂度对比：

冒泡排序

　　冒泡排序是最简单的排序之一了，其大体思想就是通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡向上升一样，因此而得名。举个栗子，对5、3、8、6、4这个无序序列进行冒泡排序。首先从后向前冒泡，4和6比较，把4交换到前面，序列变成5、3、8、4、6；同理4和8交换，变成5、3、4、8、6；3和4无需交换。5和3交换，变成3、5、4、8、6。这样一次冒泡就完了，把最小的数3排到最前面了。对剩下的序列依次冒泡就会得到一个有序序列。冒泡排序的时间复杂度为O(n^2)。

具体过程：

一趟：

    比较相邻的元素。如果第一个比第二个大，就交换它们两个；

    对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

    针对所有的元素重复以上的步骤，除了最后一个；

（一趟下来，最大的那个数就排在了最后面，那么下一趟对前n-1个数做同样的操作）

重复步骤1~3，直到排序完成。

动图演示

黄色表示已排序部分，蓝色表示未排序部分，

实现代码：

Java实现：

/**
 * 冒泡排序
 *
 * @param arr
 * @return
 */
public static void BubSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

C++实现：

void BubbleSort::bubbleSort(int arr[], int n) {
    if (arr == nullptr || n == 0)
        return;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n - 1 - i; ++j) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

选择排序

　　选择排序的思想其实和冒泡排序有点类似，都是在一次排序后把最小的元素放到最前面。但是过程不同，冒泡排序是通过相邻的比较和交换。而选择排序是通过对整体的选择。举个栗子，对5,3,8,6,4这个无序序列进行简单选择排序，首先要选择5以外的最小数来和5交换，也就是选择3和5交换，一次排序后就变成了3,5,8,6,4.对剩下的序列一次进行选择和交换，最终就会得到一个有序序列。其实选择排序可以看成冒泡排序的优化，因为其目的相同，只是选择排序只有在确定了最小数的前提下才进行交换，大大减少了交换的次数。选择排序的时间复杂度为O(n^2)。

算法描述：

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1..n]，有序区为空；

第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

n-1趟结束，数组有序化了。

动图演示：

黄色表示已排序部分，蓝色表示未排序部分，红色表示从未排序中选择的最小值

实现代码：

Java实现：

pubilc static int[] selectionSort(int[] arr) {
    int len = arr.length;
    int index , temp;
    for (int i = 0; i < len - 1; i++) {
        index = i;
        for (int j = i + 1; j < len; j++) {
            if (arr[j] < arr[index ]) {    // 寻找最小的数
                index = j;                // 将最小数的索引保存
            }
        }
        if (index != i) {
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
    }
    return arr;
} 

C++实现：

//选择排序法
//从该位置后面选择最小的元素放在该位置
public class SelectSort {
    
    public static void selectSort(int arr[], int n) {
        if(arr == nullptr || n == 0)
            return ;
        int minIndex = 0;
        for(int i=0; i < n - 1; i++) { //只需要比较n-1次
            minIndex = i;
            for(int j = i+1; j < n; j++) { //从i+1开始比较，因为minIndex默认为i了，i就没必要比了。
                if(arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            
            if(minIndex != i) { //如果minIndex不为i，说明找到了更小的值，交换之。
               int temp = arr[i];
               arr[i] = arr[minIndex];
               arr[minIndex] = temp;
            }
        }        
    }
}

插入排序

　　插入排序不是通过交换位置而是通过比较找到合适的位置插入元素来达到排序的目的的。相信大家都有过打扑克牌的经历，特别是牌数较大的。在分牌时可能要整理自己的牌，牌多的时候怎么整理呢？就是拿到一张牌，找到一个合适的位置插入。这个原理其实和插入排序是一样的。举个栗子，对5,3,8,6,4这个无序序列进行简单插入排序，首先假设第一个数的位置时正确的，想一下在拿到第一张牌的时候，没必要整理。然后3要插到5前面，把5后移一位，变成3,5,8,6,4.想一下整理牌的时候应该也是这样吧。然后8不用动，6插在8前面，8后移一位，4插在5前面，从5开始都向后移一位。注意在插入一个数的时候要保证这个数前面的数已经有序。简单插入排序的时间复杂度也是O(n^2)。

算法描述:

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序；

    取出下一个元素key，在已经排序的元素序列中从后向前扫描；

    如果扫描到的元素（已排序）大于新元素key，将扫描到的元素移到下一位置；

    重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

    将新元素插入到该位置后；

    从接下来的n-1个开始

重复步骤2~5。

动图演示:

实现代码：

Java实现

// 插入排序法
/*
插入排序法：
拿着当前位置元素和前面的元素进行比较，只要当前元素比前面的元素大，则插入到该元素前面
直到前面的元素不满足要求，记录插入位置。
先拿出来 再比较插入
*/
public class InsertSort {
    
    public static void insertSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        for(int i=1; i 0 && target < arr[j-1]) {
                arr[j] = arr[j-1];
                j --;
            }            
            //插入 
            arr[j] = target;
        }            
    }
}

C++实现

void InsertSort::insertSort(int arr[], int n)
{
	if (arr == nullptr || n == 0) return;

	for (int  i = 1; i < n; ++i) {
		int target = arr[i]; //待插入
		int j = i;
		while (j > 0 && target < arr[j - 1])
		{
			arr[j] = arr[j - 1];
			--j;
		}
		arr[j] = target;//插入
	}
}

快速排序

　　快速排序一听名字就觉得很高端，在实际应用当中快速排序确实也是表现最好的排序算法。快速排序虽然高端，但其实其思想是来自冒泡排序，冒泡排序是通过相邻元素的比较和交换把最小的冒泡到最顶端，而快速排序是比较和交换小数和大数，这样一来不仅把小数冒泡到上面同时也把大数沉到下面。

举个栗子：对5,3,8,6,4这个无序序列进行快速排序，思路是右指针找比基准数小的，左指针找比基准数大的，交换之。

5,3,8,6,4 用5作为比较的基准，最终会把5小的移动到5的左边，比5大的移动到5的右边。

5,3,8,6,4 首先设置i,j两个指针分别指向两端，j指针先扫描（思考一下为什么？）4比5小停止。然后i扫描，8比5大停止。交换i,j位置。

5,3,4,6,8 然后j指针再扫描，这时j扫描4时两指针相遇。停止。然后交换4和基准数。

4,3,5,6,8 一次划分后达到了左边比5小，右边比5大的目的。之后对左右子序列递归排序，最终得到有序序列。

上面留下来了一个问题为什么一定要j指针先动呢？首先这也不是绝对的，这取决于基准数的位置，因为在最后两个指针相遇的时候，要交换基准数到相遇的位置。一般选取第一个数作为基准数，那么就是在左边，所以最后相遇的数要和基准数交换，那么相遇的数一定要比基准数小。所以j指针先移动才能先找到比基准数小的数。

快速排序是不稳定的，其时间平均时间复杂度是O(nlgn)。

算法描述:

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；

重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

动图演示:

实现代码：

C++实现：

//快速排序：
/*
选择一个基准，将基准移动到数据中间，使得左边的数据都小于基准，右边的数都大于基准
递归划分，当数据元素等于1个的就是一个的时候就是有序的了
*/
void swap(int arr[], int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
int partion(int arr[], int low, int high)
{
    int privot = arr[low];          //选择第一个元素作为基准
    //推动左右指针向中间移动，即将基准移动到中间，low和high中的某一个一定是指向基准的
    while (low < high)
    {
        while ((low < high) && arr[high] >= privot)             //如果右边的数比基准大，则不用移动，否则将其交换到左边去
            high--;
        swap(arr, low, high);
        while ((low < high) && arr[low] <= privot)
            low++;
        swap(arr, low, high);
    }
    return low;         //当low=high的时候则停止划分，由于low和high在移动的过程中，总有一个是指向基准的，这里返回，low其实就是基准在数组中的索引
}
//递归划分，当划分到一个元素的时候，子数组就是有序的
void QSort(int arr[], int low, int high)
{
    if (low < high)
    {
        int idx = partion(arr, low, high);
        //递归划分划分左右子数组，让左右子数组有序
        QSort(arr, low, idx-1);
        QSort(arr, idx+1, high);
    }
}
void QucikSort(int arr[], int n)
{
    QSort(arr, 0, n - 1);
}

Java实现：

pubilc static int[] quickSort(int[] arr, int left, int right) {
    int len = arr.length,
    int partitionIndex,
    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}

 
pubilc static int partition(int[] arr, int left ,int right) {    // 分区操作
    int pivot = left,                     // 设定基准值（pivot）
    int index = pivot + 1;
    for (int i = index; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }       
    }
    swap(arr, pivot, index - 1);
    return index-1;
}


pubilc static void swap(int[] arr, int i, int j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

堆排序
        堆的相关概念我专门有一篇介绍，可以参考:数据结构堆(Heap)详解-堆的建立、插入、删除、最大堆、最小堆、堆排序等。

　　堆排序是借助堆来实现的选择排序，思想同简单的选择排序，以下以大顶堆为例。注意：如果想升序排序就使用大顶堆，反之使用小顶堆。原因是堆顶元素需要交换到序列尾部。

　　首先，实现堆排序需要解决两个问题：

　　1. 如何由一个无序序列键成一个堆？

　　2. 如何在输出堆顶元素之后，调整剩余元素成为一个新的堆？

　　第一个问题，可以直接使用线性数组来表示一个堆，由初始的无序序列建成一个堆就需要自底向上从第一个非叶元素开始挨个调整成一个堆。

　　第二个问题，怎么调整成堆？首先是将堆顶元素和最后一个元素交换。然后比较当前堆顶元素的左右孩子节点，因为除了当前的堆顶元素，左右孩子堆均满足条件，这时需要选择当前堆顶元素与左右孩子节点的较大者（大顶堆）交换，直至叶子节点。我们称这个自堆顶自叶子的调整成为筛选。

　　从一个无序序列建堆的过程就是一个反复筛选的过程。若将此序列看成是一个完全二叉树，则最后一个非终端节点是n/2取底个元素，由此筛选即可。举个栗子：

49,38,65,97,76,13,27,49序列的堆排序建初始堆和调整的过程如下：

 

 

 

动图演示:

    （1）动画从一排数字开始

    （2）先将一排数字放入数组（这个数组看做堆），显然这个堆是不满足条件的

    （3）从最后一个父节点开始对堆进行调整（heapify）使其满足堆的性质（绿色代表调整好了，浅蓝色表示正在调整）

    （4）堆构建结束后将堆顶元素与最后一个节点交换，将最大值放在最后（红色元素），剩下的n-1个元素堆的性质被破坏，需要重新做一次heapify使前n-1个元素满足堆的性质，从而循环（4）这个过程实现堆排序

实现代码：

C++实现：

/**
* 堆筛选，除了start之外，start~end均满足大顶堆的定义。
* 调整之后start~end称为一个大顶堆。
* @param arr 待调整数组
* @param start 起始指针
* @param end 结束指针
*/
void heapAdjust(int arr[], int start, int end) {
	int temp = arr[start];

	for (int i = 2 * start + 1; i <= end; i *= 2) {
		//左右孩子的节点分别为2*i+1,2*i+2

		//选择出左右孩子较小的下标
		if (i < end && arr[i] < arr[i + 1]) {
			i++;
		}
		if (temp >= arr[i]) {
			break; //已经为大顶堆，=保持稳定性。
		}
		arr[start] = arr[i]; //将子节点上移
		start = i; //下一轮筛选
	}

	arr[start] = temp; //插入正确的位置
}

void HeapSort::swap(int arr[], int i, int j) {
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}


void HeapSort::heapSort(int arr[], int n)
{
	if (arr == nullptr || n == 0)
		return;

	//建立大顶堆
	for (int i = n / 2; i >= 0; i--) {
		heapAdjust(arr, i, n - 1);
	}

	for (int i = n - 1; i >= 0; i--) {
		swap(arr, 0, i);
		heapAdjust(arr, 0, i - 1);
	}
}

Java实现：

public class HeapSort {
    
    /**
     * 堆筛选，除了start之外，start~end均满足大顶堆的定义。
     * 调整之后start~end称为一个大顶堆。
     * @param arr 待调整数组
     * @param start 起始指针
     * @param end 结束指针
     */
    public static void heapAdjust(int[] arr, int start, int end) {
        int temp = arr[start];
        
        for(int i=2*start+1; i<=end; i*=2) {
            //左右孩子的节点分别为2*i+1,2*i+2
            
            //选择出左右孩子较小的下标
            if(i < end && arr[i] < arr[i+1]) {
                i ++; 
            }
            if(temp >= arr[i]) {
                break; //已经为大顶堆，=保持稳定性。
            }
            arr[start] = arr[i]; //将子节点上移
            start = i; //下一轮筛选
        }
        
        arr[start] = temp; //插入正确的位置
    }
    
    
    public static void heapSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        
        //建立大顶堆
        for(int i=arr.length/2; i>=0; i--) {
            heapAdjust(arr, i, arr.length-1);
        }
        
        for(int i=arr.length-1; i>=0; i--) {
            swap(arr, 0, i);
            heapAdjust(arr, 0, i-1);
        }
        
    }
    
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

希尔排序

　　希尔排序是插入排序的一种高效率的实现，也叫缩小增量排序。简单的插入排序中，如果待排序列是正序时，时间复杂度是O(n)，如果序列是基本有序的，使用直接插入排序效率就非常高。希尔排序就利用了这个特点。基本思想是：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时再对全体记录进行一次直接插入排序。

举个栗子：

 

 　　从上述排序过程可见，希尔排序的特点是，子序列的构成不是简单的逐段分割，而是将某个相隔某个增量的记录组成一个子序列。如上面的例子，第一趟排序时的增量为5，第二趟排序的增量为3。由于前两趟的插入排序中记录的关键字是和同一子序列中的前一个记录的关键字进行比较，因此关键字较小的记录就不是一步一步地向前挪动，而是跳跃式地往前移，从而使得进行最后一趟排序时，整个序列已经做到基本有序，只要作记录的少量比较和移动即可。因此希尔排序的效率要比直接插入排序高。

　　希尔排序的分析是复杂的，时间复杂度是所取增量的函数，这涉及一些数学上的难题。但是在大量实验的基础上推出当n在某个范围内时，时间复杂度可以达到O(n^1.3)。

算法描述:

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

按增量序列个数k，对序列进行k 趟排序；

每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

动图演示

实现代码：

C++实现：

 

Java实现：

//核心思想还是使用插入排序算法
//通过分组，让数据在小规模内有序，减小递归增量使得整体有序

public class ShellSort {
    
    /**
     * 希尔排序的一趟插入
     * @param arr 待排数组
     * @param d 增量
     */
    public static void shellInsert(int[] arr, int d) {
        for(int i=d; i=0 && arr[j]>temp) {  //从后向前，找到比其小的数的位置   
                arr[j+d] = arr[j];    //向后挪动  
                j -= d;  
            }  
      
            if (j != i - d)    //存在比其小的数 
                arr[j+d] = temp;
            
        }
    }
    
    public static void shellSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        int d = arr.length / 2;
        while(d >= 1) {
            shellInsert(arr, d);
            d /= 2;
        }
    }

}　　

归并排序

　　归并排序是另一种不同的排序方法，因为归并排序使用了递归分治的思想，所以理解起来比较容易。其基本思想是，先递归划分子问题，然后合并结果。把待排序列看成由两个有序的子序列，然后合并两个子序列，然后把子序列看成由两个有序序列。。。。。倒着来看，其实就是先两两合并，然后四四合并。。。最终形成有序序列。空间复杂度为O(n)，时间复杂度为O(nlogn)。

举个栗子：

算法描述:

把长度为n的输入序列分成两个长度为n/2的子序列；

对这两个子序列分别采用归并排序；

将两个排序好的子序列合并成一个最终的排序序列。

动图演示:

实现代码：

//归并排序
/*
使用分治思想：
假设两个子数组是有序的，将其按照有序序列合并，合并组成新的有序数组，再与其他部分合并
*/
void merge(int arr[], int low, int mid, int high, int temp[])
{
    int i = low;         //左子数组开始位置
    int j = mid + 1;    //右子数组开始位置
    int t = 0;          //临时空间指针
    while (i <= mid && j <= high)
    {
        if (arr[i] < arr[j])
            temp[t++] = arr[i++];
        else
            temp[t++] = arr[j++];
    }
    //将左边剩余元素填充进temp中
    while (i <= mid)
        temp[t++] = arr[i++];
    //将右边子数组剩余部分填充到temp中
    while (j <= high)
        temp[t++] = arr[j++];
 
    //将融合后的数据拷贝到原来的数据对应的子空间中
    t = 0;
    while (low <= high)
    {
        arr[low++] = temp[t++];
    }
    
}
void MSort(int arr[], int low, int high, int temp[])
{
    if (low < high)             //只有low==high为一个元素的时候不用再细分自分组，融合
    {
        int mid = (low + high) / 2;
        //左子数组融合排序
        MSort(arr, low, mid, temp);
        //右子数组融合排序
        MSort(arr, mid + 1, high, temp);
        //已经排序好的子数组有序融合
        merge(arr, low, mid, high, temp);
    }
 
}

计数排序

　　如果在面试中有面试官要求你写一个O(n)时间复杂度的排序算法，你千万不要立刻说：这不可能！虽然前面基于比较的排序的下限是O(nlogn)。但是确实也有线性时间复杂度的排序，只不过有前提条件，就是待排序的数要满足一定的范围的整数，而且计数排序需要比较多的辅助空间。其基本思想是，用待排序的数作为计数数组的下标，统计每个数字的个数。然后依次输出即可得到有序序列。

算法描述:

找出待排序的数组中最大和最小的元素；

统计数组中每个值为i的元素出现的次数，存入数组C的第i项；

对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；

反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

动图演示:

实现代码：

public class CountSort {
    
    public static void countSort(int[] arr) {
        if(arr == null || arr.length == 0)
            return ;
        
        int max = max(arr);
        
        int[] count = new int[max+1];
        Arrays.fill(count, 0);
        
        for(int i=0; i max)
                max = ele;
        }
        
        return max;
    }

}

桶排序

　　桶排序算是计数排序的一种改进和推广，但是网上有许多资料把计数排序和桶排序混为一谈。其实桶排序要比计数排序复杂许多。

　　对桶排序的分析和解释借鉴这位兄弟的文章（有改动）：http://hxraid.iteye.com/blog/647759

　　桶排序的基本思想：

 　　假设有一组长度为N的待排关键字序列K[1....n]。首先将这个序列划分成M个的子区间(桶) 。然后基于某种映射函数 ，将待排序列的关键字k映射到第i个桶中(即桶数组B的下标 i) ，那么该关键字k就作为B[i]中的元素(每个桶B[i]都是一组大小为N/M的序列)。接着对每个桶B[i]中的所有元素进行比较排序(可以使用快排)。然后依次枚举输出B[0]....B[M]中的全部内容即是一个有序序列。bindex=f(key)   其中，bindex 为桶数组B的下标(即第bindex个桶), k为待排序列的关键字。桶排序之所以能够高效，其关键在于这个映射函数，它必须做到：如果关键字k1

举个栗子：

　　假如待排序列K= {49、 38 、 35、 97 、 76、 73 、 27、 49 }。这些数据全部在1—100之间。因此我们定制10个桶，然后确定映射函数f(k)=k/10。则第一个关键字49将定位到第4个桶中(49/10=4)。依次将所有关键字全部堆入桶中，并在每个非空的桶中进行快速排序后得到如图所示。只要顺序输出每个B[i]中的数据就可以得到有序序列了。

桶排序分析：

　　桶排序利用函数的映射关系，减少了几乎所有的比较工作。实际上，桶排序的f(k)值的计算，其作用就相当于快排中划分，希尔排序中的子序列，归并排序中的子问题，已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。　

对N个关键字进行桶排序的时间复杂度分为两个部分：

　　(1) 循环计算每个关键字的桶映射函数，这个时间复杂度是O(N)。

　　(2) 利用先进的比较排序算法对每个桶内的所有数据进行排序，其时间复杂度为  ∑ O(Ni*logNi) 。其中Ni 为第i个桶的数据量。

很显然，第(2)部分是桶排序性能好坏的决定因素。尽量减少桶内数据的数量是提高效率的唯一办法(因为基于比较排序的最好平均时间复杂度只能达到O(N*logN)了)。因此，我们需要尽量做到下面两点：

　　(1) 映射函数f(k)能够将N个数据平均的分配到M个桶中，这样每个桶就有[N/M]个数据量。

　　(2) 尽量的增大桶的数量。极限情况下每个桶只能得到一个数据，这样就完全避开了桶内数据的“比较”排序操作。当然，做到这一点很不容易，数据量巨大的情况下，f(k)函数会使得桶集合的数量巨大，空间浪费严重。这就是一个时间代价和空间代价的权衡问题了。

对于N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：

             O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)

当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。

总结： 桶排序的平均时间复杂度为线性的O(N+C)，其中C=N*(logN-logM)。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。 当然桶排序的空间复杂度 为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。此外，桶排序是稳定的。

实现代码：

 

public class BucketSort {
    
    public static void bucketSort(int[] arr) {
        if(arr == null && arr.length == 0)
            return ;
        
        int bucketNums = 10; //这里默认为10，规定待排数[0,100)
        List> buckets = new ArrayList>(); //桶的索引
        
        for(int i=0; i<10; i++) {
            buckets.add(new LinkedList()); //用链表比较合适
        }
        
        //划分桶
        for(int i=0; i bucket : buckets) {
            for(int ele : bucket) {
                arr[k++] = ele;
            }
        }
    }
    
    /**
     * 映射函数
     * @param x
     * @return
     */
    public static int f(int x) {
        return x / 10;
    }

}

 

基数排序

　　基数排序又是一种和前面排序方式不同的排序方式，基数排序不需要进行记录关键字之间的比较。基数排序是一种借助多关键字排序思想对单逻辑关键字进行排序的方法。所谓的多关键字排序就是有多个优先级不同的关键字。比如说成绩的排序，如果两个人总分相同，则语文高的排在前面，语文成绩也相同则数学高的排在前面。。。如果对数字进行排序，那么个位、十位、百位就是不同优先级的关键字，如果要进行升序排序，那么个位、十位、百位优先级一次增加。基数排序是通过多次的收分配和收集来实现的，关键字优先级低的先进行分配和收集。

举个栗子：

 

 

算法描述：

取得数组中的最大数，并取得位数；

arr为原始数组，从最低位开始取每个位组成radix数组；

对radix进行计数排序（利用计数排序适用于小范围数的特点）；

动图演示：

从一排全黑的数字开始：

    先排列按照个位数的大小，将数字分配到不同的桶里，这一遍分完了，虽然数据依然是乱序，但是我们可以看到如果这些数字只有个位数，当 收集的时候可以发现只要仅有个位数的数字已经是有序的了

    同理再排列十位数，再次收集的时候，只要是仅有两位数的数字已经是有序的了

实现代码：

 

/*
 * 获取数组a中最大值
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 */
int get_max(int a[], int n)
{
    int i, max;
 
    max = a[0];
    for (i = 1; i < n; i++)
        if (a[i] > max)
            max = a[i];
    return max;
}
 
/*
 * 对数组按照"某个位数"进行排序(桶排序)
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 *     exp -- 指数。对数组a按照该指数进行排序。
 *
 * 例如，对于数组a={50, 3, 542, 745, 2014, 154, 63, 616}；
 *    (01) 当exp=1表示按照"个位"对数组a进行排序
 *    (02) 当exp=10表示按照"十位"对数组a进行排序
 *    (03) 当exp=100表示按照"百位"对数组a进行排序
 *    ...
 */
void count_sort(int a[], int n, int exp)
{
    int output[n];             // 存储"被排序数据"的临时数组
    int i, buckets[10] = {0};
 
    // 将数据出现的次数存储在buckets[]中
    for (i = 0; i < n; i++)
        buckets[ (a[i]/exp)%10 ]++;
 
    // 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
    for (i = 1; i < 10; i++)
        buckets[i] += buckets[i - 1];
 
    // 将数据存储到临时数组output[]中
    for (i = n - 1; i >= 0; i--)
    {
        output[buckets[ (a[i]/exp)%10 ] - 1] = a[i];
        buckets[ (a[i]/exp)%10 ]--;
    }
 
    // 将排序好的数据赋值给a[]
    for (i = 0; i < n; i++)
        a[i] = output[i];
}
 
/*
 * 基数排序
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 */
void radix_sort(int a[], int n)
{
    int exp;    // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
    int max = get_max(a, n);    // 数组a中的最大值
 
    // 从个位开始，对数组a按"指数"进行排序
    for (exp = 1; max/exp > 0; exp *= 10)
        count_sort(a, n, exp);
}

总结

　　在前面的介绍和分析中我们提到了冒泡排序、选择排序、插入排序三种简单的排序及其变种快速排序、堆排序、希尔排序三种比较高效的排序。后面我们又分析了基于分治递归思想的归并排序还有计数排序、桶排序、基数排序三种线性排序。我们可以知道排序算法要么简单有效，要么是利用简单排序的特点加以改进，要么是以空间换取时间在特定情况下的高效排序。但是这些排序方法都不是固定不变的，需要结合具体的需求和场景来选择甚至组合使用。才能达到高效稳定的目的。没有最好的排序，只有最适合的排序。

　　下面就总结一下排序算法的各自的使用场景和适用场合。

　　1. 从平均时间来看，快速排序是效率最高的，但快速排序在最坏情况下的时间性能不如堆排序和归并排序。而后者相比较的结果是，在n较大时归并排序使用时间较少，但使用辅助空间较多。

　　2. 上面说的简单排序包括除希尔排序之外的所有冒泡排序、插入排序、简单选择排序。其中直接插入排序最简单，但序列基本有序或者n较小时，直接插入排序是好的方法，因此常将它和其他的排序方法，如快速排序、归并排序等结合在一起使用。

　　3. 基数排序的时间复杂度也可以写成O(d*n)。因此它最使用于n值很大而关键字较小的的序列。若关键字也很大，而序列中大多数记录的最高关键字均不同，则亦可先按最高关键字不同，将序列分成若干小的子序列，而后进行直接插入排序。

　　4. 从方法的稳定性来比较，基数排序是稳定的内排方法，所有时间复杂度为O(n^2)的简单排序也是稳定的。但是快速排序、堆排序、希尔排序等时间性能较好的排序方法都是不稳定的。稳定性需要根据具体需求选择。

　　5. 上面的算法实现大多数是使用线性存储结构，像插入排序这种算法用链表实现更好，省去了移动元素的时间。具体的存储结构在具体的实现版本中也是不同的。

附：基于比较排序算法时间下限为O(nlogn)的证明：

　　基于比较排序下限的证明是通过决策树证明的，决策树的高度Ω（nlgn），这样就得出了比较排序的下限。

首先要引入决策树。 首先决策树是一颗二叉树，每个节点表示元素之间一组可能的排序，它予以京进行的比较相一致，比较的结果是树的边。 先来说明一些二叉树的性质，令T是深度为d的二叉树，则T最多有2^片树叶。 具有L片树叶的二叉树的深度至少是logL。 所以，对n个元素排序的决策树必然有n!片树叶（因为n个数有n!种不同的大小关系），所以决策树的深度至少是log(n!)，即至少需要log(n!)次比较。 而 log(n!)=logn+log(n-1)+log(n-2)+...+log2+log1 >=logn+log(n-1)+log(n-2)+...+log(n/2) >=(n/2)log(n/2) >=(n/2)logn-n/2 =O(nlogn) 所以只用到比较的排序算法最低时间复杂度是O(nlogn)。

参考资料：
　　《数据结构》 严蔚敏 吴伟民 编著
　　  桶排序分析：http://hxraid.iteye.com/blog/647759
　　  部分排序算法分析与介绍：http://www.cnblogs.com/weixliu/archive/2012/12/23/2829671.html