下面汇总 8 种常用排序：插入（直接插入、希尔）、交换（冒泡、快速）、选择（直接选择、堆）、归并、分配（基数）。辅助空间最多的是归并，最少的是堆；平均最快的是快速排序。不稳定的三种：快速、希尔、堆。
资料由网络整理，如有问题欢迎指正。原文：Java常用排序算法/程序员必须掌握的8大排序算法 ；参考 java排序算法总结。
| 算法 |
类别 |
稳定 |
辅助空间 |
平均 |
| 直接插入 |
插入 |
稳定 |
O(1) |
O(n²) |
| 希尔 |
插入 |
不稳定 |
O(1) |
视增量，优于插入 |
| 简单选择 |
选择 |
不稳定* |
O(1) |
O(n²) |
| 堆排序 |
选择 |
不稳定 |
O(1) 最少 |
O(n log n) |
| 冒泡 |
交换 |
稳定 |
O(1) |
O(n²) |
| 快速 |
交换 |
不稳定 |
O(log n) 递归栈 |
平均最快 O(n log n) |
| 归并 |
归并 |
稳定 |
O(n) 最多 |
O(n log n) |
| 基数 |
分配 |
稳定 |
O(n+k) 桶 |
O(d·(n+k)) |
八种排序之间的关系：
一、直接插入排序
基本思想：前面 n−1 个数（n≥2）已经有序，把第 n 个数插进这段有序区，使这 n 个数也有序。反复直到全部排完。
实例：
Java 实现：
public class insertSort {
public void insertSort(){
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
int temp=0;
for(int i=1;i<a.length;i++){
int j=i-1;
temp=a[i];
for(;j>=0&&temp<a[j];j--){
a[j+1]=a[j]; //将大于temp的值整体后移一个单位
}
a[j+1]=temp;
}
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
二、希尔排序（最小增量排序）
先按增量 d（常见 n/2）分组，每组下标相差 d，组内做直接插入；再把增量缩成 d/2 分组再插。直到增量变成 1，再做一次直接插入，排序完成。
实例：
Java 实现：
public class shellSort {
public void shellSort(){
int a[]={1,54,6,3,78,34,12,45,56,100};
double d1=a.length;
int temp=0;
while(true){
d1= Math.ceil(d1/2);
int d=(int) d1;
for(int x=0;x<d;x++){
for(int i=x+d;i<a.length;i+=d){
int j=i-d;
temp=a[i];
for(;j>=0&&temp<a[j];j-=d){
a[j+d]=a[j];
}
a[j+d]=temp;
}
}
if(d==1){
break;
}
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
三、简单选择排序
选出最小的与第一个位置交换；再在剩下的数里找最小的与第二个位置交换，直到倒数第二个和最后一个比较完。
实例：
Java 实现：
public class selectSort {
public void selectSort(){
int a[]={1,54,6,3,78,34,12,45};
int position=0;
for(int i=0;i<a.length;i++){
int j=i+1;
position=i;
int temp=a[i];
for(;j<a.length;j++){
if(a[j]<temp){
temp=a[j];
position=j;
}
}
a[position]=a[i];
a[i]=temp;
}
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
}
四、堆排序
堆排序是树形选择排序，是对直接选择的改进。具有 n 个元素的序列 (h1,h2,…,hn)，当且仅当满足 (hi≥h2i 且 hi≥h2i+1) 或 (hi≤h2i 且 hi≤h2i+1)（i=1…n/2）时称为堆。这里只讨论前者（大顶堆）：堆顶必是最大项。完全二叉树能直观表示堆：根是堆顶，其余为左右子树。
起初把待排序列看成顺序存储的二叉树，调整成堆，根最大；把根与最后一个结点交换，再对前面 n−1 个数重建堆。直到只剩两个结点也交换。所以堆排序需要两个过程：建堆，以及堆顶与末元交换。对应两个函数：渗透建堆，反复调用完成排序。
实例。初始序列：46,79,56,38,40,84。建堆：
交换，从堆中踢出最大数：
剩余结点再建堆，再交换踢出最大数：
依次类推：最后剩两个结点交换，踢出一个，排序完成。
Java 实现：
import java.util.Arrays;
publicclass HeapSort {
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
public HeapSort(){
heapSort(a);
}
public void heapSort(int[] a){
System.out.println("开始排序");
int arrayLength=a.length;
//循环建堆
for(int i=0;i<arrayLength-1;i++){
//建堆
buildMaxHeap(a,arrayLength-1-i);
//交换堆顶和最后一个元素
swap(a,0,arrayLength-1-i);
System.out.println(Arrays.toString(a));
}
}
private void swap(int[] data, int i, int j) {
// TODO Auto-generated method stub
int tmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
//对data数组从0到lastIndex建大顶堆
privatevoid buildMaxHeap(int[] data, int lastIndex) {
// TODO Auto-generated method stub
//从lastIndex处节点（最后一个节点）的父节点开始
for(int i=(lastIndex-1)/2;i>=0;i--){
//k保存正在判断的节点
int k=i;
//如果当前k节点的子节点存在
while(k*2+1<=lastIndex){
//k节点的左子节点的索引
int biggerIndex=2*k+1;
//如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
if(biggerIndex<lastIndex){
//若果右子节点的值较大
if(data[biggerIndex]<data[biggerIndex+1]){
//biggerIndex总是记录较大子节点的索引
biggerIndex++;
}
}
//如果k节点的值小于其较大的子节点的值
if(data[k]<data[biggerIndex]){
//交换他们
swap(data,k,biggerIndex);
//将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
k=biggerIndex;
}else{
break;
}
}
}
}
}
五、冒泡排序
对当前还未排好的区间，自上而下比较相邻两个数，大的往下沉、小的往上冒。一旦发现相邻两数次序与要求相反，就互换。
实例：
Java 实现：
publicclass bubbleSort {
publicbubbleSort(){
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
int temp=0;
for(int i=0;i<a.length-1;i++){
for(int j=0;j<a.length-1-i;j++){
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
六、快速排序
选一个基准（通常第一个或最后一个），一趟扫描把序列分成两部分：比基准小的、大于等于基准的。此时基准已在最终位置，再对左右两段递归。
实例：
Java 实现：
public class quickSort {
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
publicquickSort(){
quick(a);
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
publicint getMiddle(int[] list, int low, int high) {
int tmp =list[low]; //数组的第一个作为中轴
while (low < high){
while (low < high&& list[high] >= tmp) {
high--;
}
list[low] =list[high]; //比中轴小的记录移到低端
while (low < high&& list[low] <= tmp) {
low++;
}
list[high] =list[low]; //比中轴大的记录移到高端
}
list[low] = tmp; //中轴记录到尾
return low; //返回中轴的位置
}
publicvoid _quickSort(int[] list, int low, int high) {
if (low < high){
int middle =getMiddle(list, low, high); //将list数组进行一分为二
_quickSort(list, low, middle - 1); //对低字表进行递归排序
_quickSort(list,middle + 1, high); //对高字表进行递归排序
}
}
publicvoid quick(int[] a2) {
if (a2.length > 0) { //查看数组是否为空
_quickSort(a2,0, a2.length - 1);
}
}
}
七、归并排序
把两个（或更多）有序表合并成一个新有序表：先把待排序列分成若干有序子序列，再合并成整体有序。
实例：
Java 实现：
import java.util.Arrays;
publicclass mergingSort {
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
publicmergingSort(){
sort(a,0,a.length-1);
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
publicvoid sort(int[] data, int left, int right) {
// TODO Auto-generatedmethod stub
if(left<right){
//找出中间索引
int center=(left+right)/2;
//对左边数组进行递归
sort(data,left,center);
//对右边数组进行递归
sort(data,center+1,right);
//合并
merge(data,left,center,right);
}
}
publicvoid merge(int[] data, int left, int center, int right) {
// TODO Auto-generatedmethod stub
int [] tmpArr=newint[data.length];
int mid=center+1;
//third记录中间数组的索引
int third=left;
int tmp=left;
while(left<=center&&mid<=right){
//从两个数组中取出最小的放入中间数组
if(data[left]<=data[mid]){
tmpArr[third++]=data[left++];
}else{
tmpArr[third++]=data[mid++];
}
}
//剩余部分依次放入中间数组
while(mid<=right){
tmpArr[third++]=data[mid++];
}
while(left<=center){
tmpArr[third++]=data[left++];
}
//将中间数组中的内容复制回原数组
while(tmp<=right){
data[tmp]=tmpArr[tmp++];
}
System.out.println(Arrays.toString(data));
}
}
八、基数排序
把所有待比较的正整数统一成同样的数位长度，短的前面补零。从最低位开始，依次做一次稳定分配；从最低位排到最高位，序列就有序了。
实例：
Java 实现：
import java.util.ArrayList;
import java.util.List;
public class radixSort {
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51};
public radixSort(){
sort(a);
for(inti=0;i<a.length;i++){
System.out.println(a[i]);
}
}
public void sort(int[] array){
//首先确定排序的趟数;
int max=array[0];
for(inti=1;i<array.length;i++){
if(array[i]>max){
max=array[i];
}
}
int time=0;
//判断位数;
while(max>0){
max/=10;
time++;
}
//建立10个队列;
List<ArrayList> queue=newArrayList<ArrayList>();
for(int i=0;i<10;i++){
ArrayList<Integer>queue1=new ArrayList<Integer>();
queue.add(queue1);
}
//进行time次分配和收集;
for(int i=0;i<time;i++){
//分配数组元素;
for(intj=0;j<array.length;j++){
//得到数字的第time+1位数;
int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
ArrayList<Integer>queue2=queue.get(x);
queue2.add(array[j]);
queue.set(x, queue2);
}
int count=0;//元素计数器;
//收集队列元素;
for(int k=0;k<10;k++){
while(queue.get(k).size()>0){
ArrayList<Integer>queue3=queue.get(k);
array[count]=queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
}
一句话总结：八种排序先分清稳定性和额外空间：要稳定选归并或插入，要原地选堆，平均要快选快排。
