比较
| 名称 | 数据对象 | 稳定性 | 时间复杂度 | 额外空间复杂度 | 描述 | |
|---|---|---|---|---|---|---|
| 平均 | 最坏 | |||||
| 冒泡排序 | 数组 |  |
{\displaystyle O(n^{2})} |
{\displaystyle O(1)} |
（无序区，有序区）。 从无序区通过交换找出最大元素放到有序区前端。 |
|
| 选择排序 | 数组 |  |
{\displaystyle O(n^{2})} |
{\displaystyle O(1)} |
（有序区，无序区）。 在无序区里找一个最小的元素跟在有序区的后面。对数组：比较得多，换得少。 |
|
| 链表 | |
|||||
| 插入排序 | 数组、链表 | |
{\displaystyle O(n^{2})} |
{\displaystyle O(1)} |
（有序区，无序区）。 把无序区的第一个元素插入到有序区的合适的位置。对数组：比较得少，换得多。 |
|
| 堆排序 | 数组 | |
{\displaystyle O(n\log n)} |
{\displaystyle O(1)} |
（最大堆，有序区）。 从堆顶把根卸出来放在有序区之前，再恢复堆。 |
|
| 归并排序 | 数组 | |
{\displaystyle O(n\log ^{2}n)} |
{\displaystyle O(1)} |
把数据分为两段，从两段中逐个选最小的元素移入新数据段的末尾。 可从上到下或从下到上进行。 |
|
| {\displaystyle O(n\log n)} |
{\displaystyle O(n)+O(\log n)} 如果不是从下到上 |
|||||
| 链表 | {\displaystyle O(1)} |
|||||
| 快速排序 | 数组 | |
{\displaystyle O(n\log n)} |
{\displaystyle O(n^{2})} |
{\displaystyle O(\log n)} |
（小数，基准元素，大数）。 在区间中随机挑选一个元素作基准，将小于基准的元素放在基准之前，大于基准的元素放在基准之后，再分别对小数区与大数区进行排序。 |
| 希尔排序 | 数组 | |
{\displaystyle O(n\log ^{2}n)} |
{\displaystyle O(n^{2})} |
{\displaystyle O(1)} |
每一轮按照事先决定的间隔进行插入排序，间隔会依次缩小，最后一次一定要是1。 |
| 计数排序 | 数组、链表 | |
{\displaystyle O(n+m)} |
{\displaystyle O(n+m)} |
统计小于等于该元素值的元素的个数i，于是该元素就放在目标数组的索引i位（i≥0）。 | |
| 桶排序 | 数组、链表 | |
{\displaystyle O(n)} |
{\displaystyle O(m)} |
将值为i的元素放入i号桶，最后依次把桶里的元素倒出来。 | |
| 基数排序 | 数组、链表 | |
{\displaystyle O(k\times n)} |
{\displaystyle O(n^{2})} |
一种多关键字的排序算法，可用桶排序实现。 | |
本次介绍的排序有两种、希尔排序和快速排序
希尔排序
定义
希尔排序按其设计者
希尔（Donald Shell）的名字命名，该算法由1959年公布。一些老版本教科书和参考手册把该算法命名为Shell-Metzner，即包含Marlene Metzner Norton的名字，但是根据Metzner本人的说法，“我没有为这种算法做任何事，我的名字不应该出现在算法的名字中。”
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
-
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
-
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
基本思想
先取一个小于n的整数d1作为第一个
增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行
直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量
=1(
<
…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
该方法实质上是一种分组插入方法
比较相隔较远距离（称为
增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的
排序算法中实现了这一思想。算法先将要排序的一组数按某个
增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当
增量减到1时，整个要排序的数被分成一组，排序完成。
一般的初次取序列的一半为
增量，以后每次减半，直到增量为1。
给定实例的shell排序的排序过程
假设待排序文件有10个记录，其关键字分别是：
49，38，65，97，76，13，27，49，55，04。
增量序列的取值依次为：
5，3，1
希尔排序实例
代码实现
/*
* 希尔排序
*/
public class ShellSort {
/**
* 排序方法
*/
public static void sort(long[] arr) {
//初始化一个间隔
int h = 1;
//计算最大间隔
while(h < arr.length / 3) {
h = h * 3 + 1;
}
while(h > 0) {
//进行插入排序
long tmp = 0;
for(int i = h; i < arr.length; i++) {
tmp = arr[i];
int j = i;
while(j > h - 1 && arr[j - h] >= tmp) {
arr[j] = arr[j - h];
j -= h;
}
arr[j] = tmp;
}
//减小间隔
h = (h - 1) / 3;
}
}
}
快速排序
简介
快速排序（Quicksort）是对
冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以
递归进行，以此达到整个数据变成有序
序列。
思路分析
设要排序的
数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的
排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
1）设置两个变量i、j，
排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给
key，即
key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于
key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于
key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于
key,4中A[i]不大于
key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
排序演示
假设用户输入了如下数组：
|
下标
|
0
|
1
|
2
|
3
|
4
|
5
|
|
数据
|
6
|
2
|
7
|
3
|
8
|
9
|
创建变量i=0（指向第一个数据）, j=5(指向最后一个数据), k=6(
赋值为第一个数据的值)。
我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找，不断递减变量j的值，我们找到第一个下标3的数据比6小，于是把数据3移到下标0的位置，把下标0的数据6移到下标3，完成第一次比较：
|
下标
|
0
|
1
|
2
|
3 |
4
|
5
|
|
数据
|
3
|
2
|
7
|
6
|
8
|
9
|
i=0 j=3 k=6
接着，开始第二次比较，这次要变成找比k大的了，而且要从前往后找了。递加变量i，发现下标2的数据是第一个比k大的，于是用下标2的数据7和j指向的下标3的数据的6做交换，数据状态变成下表：
|
下标
|
0
|
1
|
2
|
3
|
4
|
5
|
|
数据
|
3
|
2
|
6
|
7
|
8
|
9
|
i=2 j=3 k=6
称上面两次比较为一个循环。
接着，再递减变量j，不断重复进行上面的循环比较。
在本例中，我们进行一次循环，就发现i和j“碰头”了：他们都指向了下标2。于是，第一遍比较结束。得到结果如下，凡是k(=6)左边的数都比它小，凡是k右边的数都比它大：
|
下标
|
0
|
1
|
2
|
3
|
4
|
5
|
|
数据
|
3
|
2
|
6
|
7
|
8
|
9
|
如果i和j没有碰头的话，就递加i找大的，还没有，就再递减j找小的，如此反复，不断循环。注意判断和寻找是同时进行的。
然后，对k两边的数据，再分组分别进行上述的过程，直到不能再分组为止。
注意：第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。
代码实现
/*
* 快速排序
*/
public class QuickSort {
/**
* 划分数组
*/
public static int partition(long arr[],int left, int right,long point) {
int leftPtr = left - 1;
int rightPtr = right;
while(true) {
//循环,将比关键字小的留在左端
while(leftPtr < rightPtr && arr[++leftPtr] < point);
//循环，将比关键字大的留在右端
while(rightPtr > leftPtr && arr[--rightPtr] > point);
if(leftPtr >= rightPtr) {
break;
} else {
long tmp = arr[leftPtr];
arr[leftPtr] = arr[rightPtr];
arr[rightPtr] = tmp;
}
}
//将关键字和当前leftPtr所指的这一个进行交换
long tmp = arr[leftPtr];
arr[leftPtr] = arr[right];
arr[right] = tmp;
return leftPtr;
}
public static void sort(long[] arr, int left, int right) {
if(right - left <= 0) {
return;
} else {
//设置关键字
long point = arr[right];
//获得切入点，同时对数组进行划分
int partition = partition(arr, left, right, point);
//对左边的子数组进行快速排序
sort(arr,left,partition - 1);
//对右边的子数组进行快速排序
sort(arr,partition + 1, right);
}
}
}