ps：朋友，这里的算法实现代码都是自己根据思路来进行的，可能某些方面的细节没考虑到而导致存在bug，如果发现bug之处请在评论里进行指正，非常感谢！
一、算法概述
1、算法分类
比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O（n*logn），所以也被称为非线性时间比较类排序
非比较排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
2、算法复杂度
相关概念
稳定性：如果在原来的数组中，a本来在b的前面，而a=b，在比较完之后a还是在b之前，那么称此时是稳定的；相反，要是a跑到了b的后面，那么此时不具有稳定性
时间复杂度：是指对排序的数据总的操作次数，反应当数组规模n变化时，操作次数呈现什么规律
空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数
二、算法分类及其实现
1、冒泡排序（Bubble Sort）
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法实现步骤
a，比较相邻的元素。如果第一个比第二个大，就交换它们两个；
b，对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
c，针对所有的元素重复以上的步骤，除了最后一个；
d，重复步骤1~3，直到排序完成。
算法实现代码
/**
* 冒泡算法排序：升序
* 时间复杂度：O n^2
* 稳定的排序算法
* @param array
*/
public static void bubbleSort(int[] array){
for (int i = 0; i < array.length; i++) {
for (int j = i; j < array.length; j++) {
//核心：比较两个数的大小，如果前者大于后者则交换两个数
if(array[i]>array[j]){
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
}
}
2、选择排序（Selection Sort）
选择排序是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
算法实现步骤
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
a，初始状态：无序区为R[1..n]，有序区为空；
b，第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录
c，R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
d，n-1趟结束，数组有序化了。
算法实现代码
/**
* 简单选择排序：升序
* 时间复杂度：O n^2
* 不稳定的排序算法
*
* @param array
*/
public static void selectSort(int[] array) {
for (int i = 0; i < array.length; i++) {
int min = array[i];//当前遍历的最小数
int minIndex = i;//当前遍历最小数的下标
for (int j = i + 1; j < array.length; j++) {
if (array[j] <= min) {//遵守选择排序满足不稳定性
min = array[j];
minIndex = j;
}
}
//找到最小数和其下标后，交换位置
array[minIndex] = array[i];
array[i] = min;
}
}
算法分析
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。
3、插入排序（Insertion Sort）
插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
算法实现步骤
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
a，从第一个元素开始，该元素可以认为已经被排序；
b，取出下一个元素，在已经排序的元素序列中从后向前扫描；
c，如果该元素（已排序）大于新元素，将该元素移到下一位置；
d，重复步骤c，直到找到已排序的元素小于或者等于新元素的位置；
e，将新元素插入到该位置后；
f，重复步骤b~e。
算法实现代码
/**
* 插入排序：升序
* 时间复杂度：O n^2
* 稳定排序算法
*
* @param array
*/
public static void insertSort(int[] array) {
//有序数组:[0,i]
for (int i = 1; i < array.length; i++) {
//无序数组待排序：[i+1,array.length-1]
//注意点1：当遍历的数是最小的数时，要放在数组首部
//注意点2：当最小数位于最右边界时，要放在数组首部
if (array[i] < array[i - 1]) {
int tmp = array[i];
for (int j = i; j >= 0; j--) {
if (j > 0 && tmp < array[j] && tmp >= array[j - 1]) {//稳定性要求">=",特殊的测试用例：{3, 2, 3, 1, 2, 3, 1, 2, 2}
array[j] = tmp;
break;
} else if (j == 0) {//当前遍历的数是最小数，在有序数组中遍历到头了，只能放入数组的头部
array[j] = tmp;
} else {
array[j] = array[j - 1];
}
}
}
}
}
算法分析
插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
4、希尔排序（Shell Sort）
简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
算法实现步骤
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
a，选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
b，按增量序列个数k，对序列进行k 趟排序；
c，每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
算法实现代码
/**
* 希尔排序：升序
* 时间复杂度：O n^1.3
* 不稳定排序算法
* 希尔增量：从array.length/2 到 1
*
* @param array
*/
//================================ErrorCode：Start================================
public static void shellSort(int[] array) {
int shell = array.length / 2;//希尔增量
while (shell >= 1) {
for (int i = array.length - shell; i < array.length; i++) {//错误代码处
for (int j = i; j >= shell; j -= shell) {
if (array[j] < array[j - shell]) {
int tmp = array[j];
array[j] = array[j - shell];
array[j - shell] = tmp;
}
}
}
shell /= 2;
}
}
//================================ErrorCode；End================================
//================================CorrectCode：Start============================
public static void shellSort(int[] array) {
int shell = array.length / 2;//希尔增量
while (shell >= 1) {
for (int i = shell; i < array.length; i++) {//错误代码改正处
for (int j = i; j >= shell; j -= shell) {
if (array[j] < array[j - shell]) {
int tmp = array[j];
array[j] = array[j - shell];
array[j - shell] = tmp;
}
}
}
shell /= 2;
}
//================================CorrectCode：End==============================
算法分析
希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。一般选择的增量序列为{n/2,(n/2)/2...1}(希尔增量)，其最坏时间复杂度依然为O(n2)，一些经过优化的增量序列如Hibbard经过复杂证明可使得最坏时间复杂度为O(n3/2)。
5、归并排序（Merge Sort）
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
算法实现步骤
a，把长度为n的输入序列分成两个长度为n/2的子序列；
b，对这两个子序列分别采用归并排序；
c，将两个排序好的子序列合并成一个最终的排序序列。
算法实现代码
递归：
/**
* 归并排序：升序——递归实现
* 时间复杂度：O n*log n
* 稳定的排序算法
*
* @param array
*/
public static void mergeSort(int[] array) {
mergeSort(array, 0, array.length - 1);
}
/**
* 分治：把一个完整的数组划分成"几"个数组来分别排序
*
* @param array
* @param left
* @param right
*/
public static void mergeSort(int[] array, int left, int right) {
if (left >= right) {
return;
}
int mid = (left + right) / 2;
mergeSort(array, left, mid);
mergeSort(array, mid + 1, right);
mergeSort(array, left, mid, right);
}
/**
* 把两个数组排序成一个数组
*
* @param array
* @param left 左边数组的开始下标
* @param mid 左边数组的结束下标
* @param right 右边数组的结束下标（右边数组的开始下标为mid+1）
*/
private static void mergeSort(int[] array, int left, int mid, int right) {
int[] arrayTmp = new int[right - left + 1];//存放已经比较好的数组
int indexOfTmp = 0;//存放临时数组的元素下标
int i = left;//左边的数组开始下标
int j = mid + 1;//右边的数组开始下标
while (i <= mid && j <= right) {//mid为左边数组的结束下标
if (array[i] < array[j]) {
arrayTmp[indexOfTmp++] = array[i++];
} else {
arrayTmp[indexOfTmp++] = array[j++];
}
}
//左边的数组元素还未全部加入到临时数组
while (i <= mid) {
arrayTmp[indexOfTmp++] = array[i++];
}
//右边的数组元素还未全部加入到临时数组
while (j <= right) {
arrayTmp[indexOfTmp++] = array[j++];
}
//把临时数组的元素准确的加入到原数组中
for (int k = 0; k < arrayTmp.length; k++) {
array[right--] = arrayTmp[--indexOfTmp];
}
}
非递归：
/**
* 归并排序：升序——非递归实现
* 时间复杂度：O n*log n
* 稳定的排序算法
*
* @param array
*/
public static void mergeSort(int[] array) {
//开辟一个原数组大小相同的临时数组，用来存储已经比较好的数组元素
int[] arrayTmp = new int[array.length];
//逐级比较，第一次比较2个，第2次比较4个，....，第i次比较2^i个
for (int i = 1; i < array.length; i *= 2) {
//左边的数组每次都是从0开始
int left_start = 0;
//其他两边数组的边界：左闭右开规则
int left_end;
int right_start;
int right_end;
for (; left_start < array.length - i; left_start = right_end) {
left_end = left_start + i;
right_start = left_end;
right_end = right_start + i;
//控制右边数组的结束边界不超出数组规模
if (right_end > array.length) {
right_end = array.length;
}
//已经比较完并放入临时数组的下标，每次都是从0开始
int indexOfTmp = 0;
while (left_start < left_end && right_start < right_end) {
if (array[left_start] < array[right_start]) {
arrayTmp[indexOfTmp++] = array[left_start++];
} else {
arrayTmp[indexOfTmp++] = array[right_start++];
}
}
//左边的数组元素还未比较完毕，把剩余元素加入到临时数组中去
while (left_start < left_end) {
arrayTmp[indexOfTmp++] = array[left_start++];
}
//右边的数组元素还未比较完毕，把剩余元素加入到临时数组中去
while (right_start < right_end) {
arrayTmp[indexOfTmp++] = array[right_start++];
}
//把已经比较好并放入临时数组的元素准确的放入原数组中去
for (int j = right_end; indexOfTmp > 0; ) {//由于right_end在for循环结束后还要再次赋值给left_start,所以right_end不能改变
array[--j] = arrayTmp[--indexOfTmp];
}
}
}
}
算法分析
归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。
6、快速排序（Quick Sort）
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
算法实现步骤
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
a，从数列中挑出一个元素，称为 “基准”（pivot）；
b，重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
c，递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
算法实现代码
/**
* 快速排序：升序
* 时间复杂度：O n*log n
* 不稳定排序算法
*
* @param array
*/
public static void quickSort(int[] array) {
quickSort(array, 0, array.length - 1);
}
/**
* 递归实现快速升序排序
*
* @param array
* @param start
* @param end
*/
private static void quickSort(int[] array, int start, int end) {
if (start >= end) {
return;
}
int low = start;
int high = end;
int pivot = array[end];//选取基准
while (low < high) {
//从前往后进行扫描，找到比pivot大的数
while (low < end && array[low] < pivot) {
low++;
}
//从后往前进行扫描，找到比pivot小的数
while (high > low && array[high] >= pivot) {
high--;
}
//交换数组里的两个数
if (low < high) {
int tmp = array[low];
array[low] = array[high];
array[high] = tmp;
}
}
//把pivot放入该在的位置
array[end] = array[low];//low有可能遍历到了end位置
array[low] = pivot;
//递归排序基准所在位置（交换完后的位置）左边的数组
quickSort(array, start, low - 1);
//递归排序基准所在位置（交换完后的位置）右边的数组
quickSort(array, high + 1, end);
}
算法分析
若采用固定基准的排序算法，存在着一个缺点：如果数组元素已经基本有序时，此时的划分就容易产生最坏的情况，即快速排序变成冒泡排序，时间复杂度为O(n^2)。解决方案：用随机基准或者三数取中的思想去替代固定基准，或者当已排序数组到达一定规模的时候，改快速排序为插入排序。
//如：当快排达到一定深度后，划分的区间很小时，再使用快排的效率不高。当待排序列的长度达到一定数值后，可以使用插入排序。
//由《数据结构与算法分析》：当待排序列长度为5~20之间，此时使用插入排序能避免一些有害的退化情形。
if (end - start + 1 < 10){
insertSort(arr,low,high);
return;
}
7、堆排序（Heap Sort）
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
算法实现步骤
a，将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
b，将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
c，由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
算法实现代码
/**
* 堆排序：升序——递归实现
* 时间复杂度：O n*log n
* 不稳定排序算法
*
* @param array
*/
public static void heapSort(int[] array) {
//1、初始化大顶堆，从最后一个非叶子结点开始(最后一个叶子节点在数组里的下标为：array.length/2)
for (int i = array.length / 2; i >= 0; i--) {
adjustHeap(array, array.length, i);
}
//初始化大顶堆成功，接下来就是从堆顶开始，每次都把堆顶元素放入数组尾端
//2、每次都从数组头开始，即每一次的堆调整之后，都会有一个元素到达自己的最终位置
for (int i = array.length - 1; i > 0; i--) {
//交换堆尾和堆顶元素
SortUtil.swap(array, 0, i);
//元素交换之后，毫无疑问，最后一个元素无需再考虑排序问题了
//接下来我们需要排序的，就是已经去掉了部分元素的堆
adjustHeap(array, i, 0);
}
}
/**
* 核心：调整为大顶堆
*
* @param array
* @param len 堆尾元素的下标，也用来表示要比较的堆长度
* @param i 当前移动的元素
*/
private static void adjustHeap(int[] array, int len, int i) {
//先把当前元素提取出来，因为当前元素可能要一直移动
int tmp = array[i];
for (int index = 2 * i + 1; index < len; index = index * 2 + 1) {//2*index+1为左子树i的左子树（i从0开始的)
if (index + 1 < len && array[index] < array[index + 1]) {//比较左右子树的节点值，找到节点值较大的那个数的下标
index = index + 1;
}
//如果左右子树中节点值大的数大于当前元素
if (tmp < array[index]) {
SortUtil.swap(array, i, index);
//如果子节点更换了，那么以子节点为根的子树会受到影响,所以，循环对子节点所在的树继续进行判断
i = index;
} else {
break;
}
}
}
8、计数排序（Counting Sort）
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
算法实现步骤
a，找出待排序的数组中最大和最小的元素；
b，统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
c，对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
d，反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
算法实现代码
/**
* 计数排序：升序
* 时间复杂度：O n+k
* 稳定排序算法
*
* @param array
*/
public static void countingSort(int[] array) {
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
for (int i = 0; i < array.length; i++) {
if (array[i] < min) {
min = array[i];
}
if (array[i] > max) {
max = array[i];
}
}
//开辟一个多余的数组来存储对应的数组
int[] arrayCopy = new int[array.length];
//用来计数的数组
int[] arrayCount = new int[max - min + 1];
//统计每个数出现的次数
for (int i = 0; i < array.length; i++) {
arrayCount[array[i] - min] += 1;
arrayCopy[i] = array[i];
}
//对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加)
for (int i = 1; i < arrayCount.length; i++) {
arrayCount[i] = arrayCount[i] + arrayCount[i - 1];
}
//反向填充数组,将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
for (int i = array.length - 1; i >= 0; i--) {
array[--arrayCount[arrayCopy[i] - min]] = arrayCopy[i];
}
}
算法分析
计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。
9、桶排序（Bucket Sort）
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。
算法实现步骤
a，设置一个定量的数组当作空桶；
b，遍历输入数据，并且把数据一个一个放到对应的桶里去；
c，对每个不是空的桶进行排序；
d，从不是空的桶里把排好序的数据拼接起来。
算法实现代码
/**
* 桶排序：升序
* 时间复杂度：O n+k
* 稳定排序算法
* 和计数排序类似，可以理解为：桶排序=计数排序+插入排序
* 测试用例：-7, 51, 3, 121, -3, 32, 21, 43, 4, 25, 56, 77, 16, 22, 87, 56, -bucketCapacity, 68, 99, 70
* 最大值：121，最小值-bucketCapacity，给安排【121-（-bucketCapacity）】/bucketCapacity+1=14个桶
*
* @param array
* @param bucketCapacity 指定每个桶可以存放多少个元素（第一个桶第一个存放元素的值为数组的最小值）
*/
public static void bucketSort(int[] array, int bucketCapacity) {
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;
for (int i = 0; i < array.length; i++) {
if (array[i] < min) {
min = array[i];
}
if (array[i] > max) {
max = array[i];
}
}
//总的桶数
int bucketTotal = (max - min) / bucketCapacity + 1;
int[][] bucketArray = new int[bucketTotal][11];//bucketArray[a][b]:a表示的是在这个"桶"里有多少个数，b表示a个数的排序
//把数组元素放入桶中
for (int i = 0; i < array.length; i++) {
//当前元素要放入第几个桶之中
int bucketIndex = (array[i] - min) / bucketCapacity;
//该桶里有几个数
int bucketNum = bucketArray[bucketIndex][0];
if (bucketNum == 0) {
//桶为空
bucketArray[bucketIndex][1] = array[i];
} else {
//桶不为空，插入到桶中正确的位置(桶里的元素降序)
while (bucketNum > 0 && array[i] < bucketArray[bucketIndex][bucketNum]) {
bucketArray[bucketIndex][bucketNum + 1] = bucketArray[bucketIndex][bucketNum];
bucketNum -= 1;
}
bucketArray[bucketIndex][bucketNum + 1] = array[i];
}
//桶的数量指示+1
bucketArray[bucketIndex][0] += 1;
}
//中途测试，测试放入桶中的元素是否正确
// testBucket(bucketArray);
//把数组里的元素成功放入了桶里,现在需要反向把桶里的元素填充到原数组中去
int eleIndex = array.length - 1;
for (int bucketIndex = bucketArray.length - 1; bucketIndex >= 0; bucketIndex--) {
int bucketNum = bucketArray[bucketIndex][0];
while (bucketNum != 0) {
array[eleIndex--] = bucketArray[bucketIndex][bucketNum--];
}
}
}
/**
* 输出存放在桶里的元素
*
* @param bucketArray
*/
private static void testBucket(int[][] bucketArray) {
for (int i = 0; i < bucketArray.length; i++) {
System.out.print("桶的下标：" + i + " ");
for (int j = 0; j < bucketArray[0].length; j++) {
if (j == 0) {
System.out.print("桶中的元素个数及排序：" + bucketArray[i][j] + " " + " | ");
} else {
System.out.print(bucketArray[i][j] + " ");
}
}
System.out.println();
}
}
中途桶元素测试：桶中的元素排序设置为降序排序，这样子反向填充数组的时候就比较方便
注意：第一个桶第一个存放元素的位置，存放的是数组的最小值
| 桶下标 | 桶中元素个数 | 桶中元素 |
|---|---|---|
| 0 | 3 | -10 -7 -3 0 0 0 0 0 0 0 |
| 1 | 2 | 3 4 0 0 0 0 0 0 0 0 |
| 2 | 1 | 16 0 0 0 0 0 0 0 0 0 |
| 3 | 3 | 21 22 25 0 0 0 0 0 0 0 |
| 4 | 1 | 32 0 0 0 0 0 0 0 0 0 |
| 5 | 1 | 43 0 0 0 0 0 0 0 0 0 |
| 6 | 3 | 51 56 56 0 0 0 0 0 0 0 |
| 7 | 1 | 68 0 0 0 0 0 0 0 0 0 |
| 8 | 2 | 70 77 0 0 0 0 0 0 0 0 |
| 9 | 1 | 87 0 0 0 0 0 0 0 0 0 |
| 10 | 1 | 99 0 0 0 0 0 0 0 0 0 |
| 11 | 0 | 0 0 0 0 0 0 0 0 0 0 |
| 12 | 0 | 0 0 0 0 0 0 0 0 0 0 |
| 13 | 1 | 121 0 0 0 0 0 0 0 0 0 |
算法分析
桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。
10、基数排序（Radix Sort）
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
算法实现步骤
a，取得数组中的最大数，并取得位数；
b，arr为原始数组，从最低位开始取每个位组成radix数组；
c，对radix进行计数排序（利用计数排序适用于小范围数的特点）；
算法实现代码
注意：这个代码不支持存在负数的数组排序
/**
* 基数排序：升序；注意：不支持存在负数的数组
* 时间复杂度：O n+k
* 稳定排序算法
* 可以把基数排序看作是只有0～9的桶排序
* 测试用例：73, 22, 93, 43, 55, 14, 28, 65, 39, 81
*
* @param array
*/
public static void radixSort(int[] array) {
//1、先找到数组中最大的那个数字
int max = Integer.MIN_VALUE;
for (int i = 0; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
}
}
//2、算出最大数字的位数
int maxRadix = 0;
while (max != 0) {
maxRadix += 1;
max /= 10;
}
//3、从低位开始比较
int divisor = 1;//被除数，第一次为1，第二次为10，...，第i次的时候为10^i
for (int i = 1; i <= maxRadix; i++) {
//定义0～9的桶
int[][] bucketArray = new int[10][array.length];
//把数组里的数按照位规则放入桶中
for (int j = 0; j < array.length; j++) {
//按照位规则，应该放入哪个桶
int bucketIndex = (array[j] / divisor) % 10;
//每个桶里已经有的数的总量
int bucketNum = bucketArray[bucketIndex][0];
if (bucketNum == 0) {
bucketArray[bucketIndex][1] = array[j];
} else {
bucketArray[bucketIndex][++bucketNum] = array[j];
}
bucketArray[bucketIndex][0] += 1;
}
//把数组里的数按照位放入对应桶后，再在把桶里的数重新串起来
int indexInArray = 0;
for (int j = 0; j < bucketArray.length; j++) {
for (int k = 1; k <= bucketArray[j][0]; k++) {
array[indexInArray++] = bucketArray[j][k];
}
}
//除数增加位级
divisor *= 10;
}
}
算法分析
基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n)，当然d要远远小于n，因此基本上还是线性级别的。
基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。