一、插入排序
直接插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
代码实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
public
class
Inseretion_Sort {
public
static
void
main(String[] args) {
//要排序的原始数组
int
score[]={
900
,
878
,
891
,
904
,
865
,
912
,
868
,
870
,
898
,
903
};
//打印数组元素
System.out.print(
"未排序数组："
);
for
(
int
i=
0
;i<score.length ;i++ ){
System.out.print(score[i]+
" "
);
}
System.out.println();
//插入算法
for
(
int
i=
1
;i<score.length ;i++ ){
for
(
int
k=i;k>
0
;k-- ){
if
(score[k]>score[k-
1
]){
int
temp=score[k];
score[k]=score[k-
1
];
score[k-
1
]=temp;
}
}
//每遍历一次数组的结果
System.out.print(
"第"
+i+
"次插入："
);
for
(
int
j=
0
;j<score.length ;j++ ){
System.out.print(score[j]+
" "
);
}
System.out.println();
}
//最终排序结果
System.out.print(
"最终排序结果："
);
for
(
int
j=
0
;j<score.length ;j++ ){
System.out.print(score[j]+
" "
);
}
System.out.println();
}
}
|
希尔排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。 它的基本思想是先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接 插人排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2< d1)，即所有记录放在同一组中进行直接插入排序为止。该方法实质上是一种分组插入方法。
代码实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
public
class
Shell_Sort {
public
static
void
main(String[] args) {
//要排序的原始数组
int
score[]={
900
,
878
,
891
,
904
,
865
,
912
,
868
,
870
,
898
,
903
};
//打印数组元素
System.out.print(
"未排序数组："
);
for
(
int
i=
0
;i<score.length ;i++ ){
System.out.print(score[i]+
" "
);
}
System.out.println();
//希尔算法
for
(
int
incre=score.length/
2
;incre>
0
;incre=incre/
2
)
{
for
(
int
i=incre;i<score.length;i++ )
{
int
temp=score[i];
int
k=
0
;
for
(k=i;k>=incre ;k=k-incre )
{
if
(temp>score[k-incre])
{
score[k]=score[k-incre];
}
else
{
break
;
}
}
score[k]=temp;
}
}
//最终排序结果
System.out.print(
"最终排序结果："
);
for
(
int
j=
0
;j<score.length ;j++ ){
System.out.print(score[j]+
" "
);
}
System.out.println();
}
}
|
二、交换排序
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 代码实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
public
class
Bubble_Sort {
public
static
void
main(String[] args) {
//要排序的原始数组
int
score[]={
900
,
878
,
891
,
904
,
865
,
912
,
868
,
870
,
898
,
903
};
//打印数组元素
System.out.print(
"未排序数组："
);
for
(
int
i=
0
;i<score.length ;i++ ){
System.out.print(score[i]+
" "
);
}
System.out.println();
//冒泡算法
for
(
int
i=
0
;i<score.length-
1
; i++){
for
(
int
k=
0
;k<score.length-i-
1
;k++ ){
if
(score[k]<score[k+
1
]){
int
temp=score[k];
score[k]=score[k+
1
];
score[k+
1
]=temp;
}
}
//每遍历一次数组的结果
System.out.print(
"第"
+(i+
1
)+
"次冒泡："
);
for
(
int
j=
0
;j<score.length ;j++ ){
System.out.print(score[j]+
" "
);
}
System.out.println();
}
//最终排序结果
System.out.print(
"最终排序结果："
);
for
(
int
j=
0
;j<score.length ;j++ ){
System.out.print(score[j]+
" "
);
}
System.out.println();
}
}
|
快速排序是由东尼·霍尔所发展的一种排序算法 基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
代码实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
package
com.mzsx.binarySearch;
import
com.google.gson.Gson;
public
class
Quick_Sort {
public
static
void
main(String[] args) {
int
array[] = {
2
,
44
,
23
,
5
,
34
,
13
,
29
,
6
,
24
,
26
,
18
,
10
,
25
,
12
,
17
};
array = quickSort(array,
0
, array.length-
1
);
for
(
int
i =
0
; i < array.length; i++) {
System.out.print(array[i] +
" "
);
}
System.out.println();
}
// 快速排序算法
public
static
int
[] quickSort(
int
[] arr,
int
lowIndex,
int
highIndex) {
if
(lowIndex < highIndex) {
int
start = arr[lowIndex];
// 起始数
int
low = lowIndex;
int
high = highIndex+
1
;
while
(
true
) {
//向右寻找大于s的数组元素的索引
while
(low +
1
< arr.length && arr[++low] < start);
//向左寻找小于s的数组元素的索引
while
(high -
1
> -
1
&& arr[--high] > start);
//如果i>j,则退出循环
if
(low >= high) {
break
;
}
else
{
// 交换i和j位置的元素值
int
temp = arr[low];
arr[low] = arr[high];
arr[high] = temp;
}
}
arr[lowIndex] = arr[high];
arr[high] = start;
// 对右边进行递归
quickSort(arr, high +
1
, highIndex);
// 对左边进行递归
quickSort(arr, lowIndex, high -
1
);
}
return
arr;
}
}
|
三、选择排序
直接选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾(目前已被排序的序列)。以此类推，直到所有元素均排序完毕。
代码实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
public
class
Select_Sort {
public
static
void
main(String[] args) {
//要排序的原始数组
int
score[]={
900
,
878
,
891
,
904
,
865
,
912
,
868
,
870
,
898
,
903
};
//打印数组元素
System.out.print(
"未排序数组："
);
for
(
int
i=
0
;i<score.length ;i++ ){
System.out.print(score[i]+
" "
);
}
System.out.println();
//选择算法
for
(
int
i=
0
;i< score.length; i++){
int
lowIndex=i;
for
(
int
k=i+
1
;k<score.length ;k++ ){
if
(score[k]>score[lowIndex]){
lowIndex=k;
}
}
int
temp=score[i];
score[i]=score[lowIndex];
score[lowIndex]=temp;
//每遍历一次数组的结果
System.out.print(
"第"
+(i+
1
)+
"次选择："
);
for
(
int
j=
0
;j<score.length ;j++ ){
System.out.print(score[j]+
" "
);
}
System.out.println();
}
//最终排序结果
System.out.print(
"最终排序结果："
);
for
(
int
j=
0
;j<score.length ;j++ ){
System.out.print(score[j]+
" "
);
}
System.out.println();
}
}
|
四、排序算法特点，算法复杂度和比较
直接插入排序
如果目标是把n个元素的序列升序排列，那么采用直接插入排序存在最好情况和最坏情况。最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需(n-1)次即可。最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。直接插入排序的赋值操作是比较操作的次数减去(n-1)次。平均来说直接插入排序算法复杂度为O(n2)。因而，直接插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么直接插入排序还是一个不错的选择。 插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为8个或以下）。
希尔排序
希尔排序是基于插入排序的一种算法， 在此算法基础之上增加了一个新的特性，提高了效率。希尔排序的时间复杂度为 O(N*(logN)2)， 没有快速排序算法快
O(N*(logN))，因此中等大小规模表现良好，对规模非常大的数据排序不是最优选择。 但是比O(N2）复杂度的算法快得多。并且希尔排序非常容易实现，算法代码短而简单。 此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多，与此同时快速排序在最坏 的情况下执行的效率会非常差。专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快， 再改成快速排序这样更高级的排序算法.
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长 很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变 相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的
冒泡排序
时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数为2），但是有两个优点：1.“编程复杂度”很低，很容易写出代码；2.具有稳定性。
其中若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为"逆序"，则需进行n(n-1）/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n)。
快速排序
在最好的情况，每次我们执行一次分割，我们会把一个数列分为两个几近相等的片段。这个意思就是每次递回调用处理一半大小的数列。因此，在到达大小为一的数列前，我们只要作 log n 次巢状的调用。这个意思就是调用树的深度是O(log n)。但是在同一阶层的两个程序调用中，不会处理到原来数列的相同部份；因此，程序调用的每一阶层总共全部仅需要O(n)的时间（每个调用有某些共同的额外耗费，但是因为在每一阶层仅仅只有O(n)个调用，这些被归纳在O(n)系数中）。结果是这个算法仅需使用O(n log n)时间。
另外一个方法是为T(n)设立一个递回关系式，也就是需要排序大小为n的数列所需要的时间。在最好的情况下，因为一个单独的快速排序调用牵涉了O(n)的工作，加上对n/2大小之数列的两个递回调用，这个关系式可以是：
-
T(n) = O(n) + 2T(n/2)
解决这种关系式型态的标准数学归纳法技巧告诉我们T(n) = O(n log n)。
事实上，并不需要把数列如此精确地分割；即使如果每个基准值将元素分开为 99% 在一边和 1% 在另一边，调用的深度仍然限制在 100log n，所以全部执行时间依然是O(n log n)。
然而，在最坏的情况是，两子数列拥有大各为 1 和 n-1，且调用树（call tree）变成为一个 n 个巢状（nested）呼叫的线性连串（chain）。第 i 次呼叫作了O(n-i)的工作量，且
递回关系式为：
-
T(n) = O(n) + T(1) + T(n - 1) = O(n) + T(n - 1)
这与插入排序和选择排序有相同的关系式，以及它被解为T(n) = O(n2)。
讨论平均复杂度情况下，即使如果我们无法随机地选择基准数值，对于它的输入之所有可能排列，快速排序仍然只需要O(n log n)时间。因为这个平均是简单地将输入之所有可能排列的时间加总起来，除以n这个因子，相当于从输入之中选择一个随机的排列。当我们这样作，基准值本质上就是随机的，导致这个算法与乱数快速排序有一样的执行时间。
更精确地说，对于输入顺序之所有排列情形的平均比较次数，可以借由解出这个递回关系式可以精确地算出来。
在这里，n-1 是分割所使用的比较次数。因为基准值是相当均匀地落在排列好的数列次序之任何地方，总和就是所有可能分割的平均。
这个意思是，平均上快速排序比理想的比较次数，也就是最好情况下，只大约比较糟39%。这意味着，它比最坏情况较接近最好情况。这个快速的平均执行时间，是快速排序比其他排序算法有实际的优势之另一个原因。
讨论空间复杂度时 被快速排序所使用的空间，依照使用的版本而定。使用原地（in-place）分割的快速排序版本，在任何递回呼叫前，仅会使用固定的額外空間。然而，如果需要产生O(log n)巢状递回呼叫，它需要在他们每一个储存一个固定数量的资讯。因为最好的情况最多需要O(log n)次的巢状递回呼叫，所以它需要O(log n)的空间。最坏情况下需要O(n)次巢状递回呼叫，因此需要O(n)的空间。
然而我们在这里省略一些小的细节。如果我们考虑排序任意很长的数列，我们必须要记住我们的变量像是left和right，不再被认为是占据固定的空间；也需要O(log n)对原来一个n项的数列作索引。因为我们在每一个堆栈框架中都有像这些的变量，实际上快速排序在最好跟平均的情况下，需要O(log2n)空间的位元数，以及最坏情况下O(n log n)的空间。然而，这并不会太可怕，因为如果一个数列大部份都是不同的元素，那么数列本身也会占据O(n log n)的空间字节。
非原地版本的快速排序，在它的任何递回呼叫前需要使用O(n)空间。在最好的情况下，它的空间仍然限制在O(n)，因为递回的每一阶中，使用与上一次所使用最多空间的一半，且
它的最坏情况是很恐怖的，需要
空间，远比数列本身还多。如果这些数列元素本身自己不是固定的大小，这个问题会变得更大；举例来说，如果数列元素的大部份都是不同的，每一个将会需要大约O(log n)为原来储存，导致最好情况是O(n log n)和最坏情况是O(n2 log n)的空间需求。
不同条件下，排序方法的选择
(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。
若要求排序稳定，则可选用归并排序。但本章介绍的从单个记录起进行两两归并的 排序算法并不值得提倡，通常可以将它和直接插入排序结合在一起使用。先利用直接插入排序求得较长的有序子文件，然后再两两归并之。因为直接插入排序是稳定的，所以改进后的归并排序仍是稳定的。
(4)在基于比较的排序方法中，每次比较两个关键字的大小之后，仅仅出现两种可能的转移，因此可以用一棵二叉树来描述比较判定过程。
当文件的n个关键字随机分布时，任何借助于"比较"的排序算法，至少需要O(nlgn)的时间。
箱排序和基数排序只需一步就会引起m种可能的转移，即把一个记录装入m个箱子之一，因此在 一般情况下，箱排序和基数排序可能在O(n)时间内完成对n个记录的排序。但是，箱排序和基数排序只适用于像字符串和整数这类有明显结构特征的关键字，而 当关键字的取值范围属于某个无穷集合(例如实数型关键字)时，无法使用箱排序和基数排序，这时只有借助于"比较"的方法来排序。
若n很大，记录的关键字位数较少且可以分解时，采用基数排序较好。虽然桶排序对关键字的结构无要求，但它也只有在关键字是随机分布时才能使平均时间达到线性阶，否则为平方阶。同时要注意，箱、桶、基数这三种分配排序均假定了关键字若为数字时，则其值均是非负的，否则将其映射到箱(桶)号时，又要增加相应的时间。
(5)有的语言(如Fortran，Cobol或Basic等)没有提供指针及递归，导致实现归并、快速(它们用递归实现较简单)和基数(使用了指针)等排序算法变得复杂。此时可考虑用其它排序。
(6)本章给出的排序算法，输人数据均是存储在一个向量中。当记录的规模较大时，为避免耗费大量的时间去移动记录，可以用链表作为存储结构。譬如插入排序、归并排序、基数排序都易于在链表上实现，使之减少记录的移动次数。但有的排序方法，如快速排序和堆排序，在链表上却难于实现，在这种情况下，可以提取关键字建立索引表，然后对索引表进行排序。然而更为简单的方法是：引人一个整型向量t作为辅助表，排序前令t[i]=i(0≤i<n)，若排序算法中要求交换R[i]和R[j]，则只需交换t[i]和t[j]即可；排序结束后，向量t就指示了记录之间的顺序关系：
R[t[0]].key≤R[t[1]].key≤…≤R[t[n-1]].key
若要求最终结果是：
R[0].key≤R[1].key≤…≤R[n-1].key
则可以在排序结束后，再按辅助表所规定的次序重排各记录，完成这种重排的时间是O(n)。
五、各排序算法时间复杂度和空间复杂度
| 排序法 |
平均时间 |
最差情形 |
稳定度 |
额外空间 |
备注 |
| 冒泡 |
O(n2) |
O(n2) |
稳定 |
O(1) |
n小时较好 |
| 交换 |
O(n2) |
O(n2) |
不稳定 |
O(1) |
n小时较好 |
| 选择 |
O(n2) |
O(n2) |
不稳定 |
O(1) |
n小时较好 |
| 插入 |
O(n2) |
O(n2) |
稳定 |
O(1) |
大部分已排序时较好 |
| 基数 |
O(logrd) |
O(logrd) |
稳定 |
O(n) |
d是关键字项数(0-9)， r是基数(个十百) |
| Shell |
O(nlogn) |
O(ns) 1<s<2 |
不稳定 |
O(1) |
s是所选分组 |
| 快速 |
O(nlogn) |
O(n2) |
不稳定 |
O(nlogn) |
n大时较好 |
| 归并 |
O(nlogn) |
O(nlogn) |
稳定 |
O(1) |
n大时较好 |
| 堆 |
O(nlogn) |
O(nlogn) |
不稳定 |
O(1) |
n大时较好 |
本文转自 梦朝思夕 51CTO博客，原文链接:http://blog.51cto.com/qiangmzsx/1414502
