一、 常用的排序算法的时间复杂度和空间复杂度
|
排序法
|
最差时间分析 |
平均时间复杂度 |
稳定度 |
空间复杂度 |
| 冒泡排序 |
O(n2) |
O(n2) |
稳定 |
O(1) |
| 快速排序 |
O(n2) |
O(n*log2n) |
不稳定 |
O(log2n)~O(n) |
| 选择排序 |
O(n2) |
O(n2) |
稳定 |
O(1) |
| 二叉树排序 |
O(n2) |
O(n*log2n) |
不一顶 |
O(n) |
|
插入排序
|
O(n2) |
O(n2) |
稳定 |
O(1) |
| 堆排序 |
O(n*log2n) |
O(n*log2n) |
不稳定 |
O(1) |
| 希尔排序 |
O |
O |
不稳定 |
O(1)
|
归并排序的最好、最坏和平均时间复杂度都是O(nlogn)，而空间复杂度是O(n)，比较次数介于(nlogn)/2和(nlogn)-n+1，赋值操作的次数是(2nlogn)。因此可以看出，归并排序算法比较占用内存，但却是效率高且稳定的排序算法。
归并排序算法再没有辅助空间借助的情况下时，时间复杂度是O(n2)。
二、 堆排序：
1.堆
堆实际上是一棵完全二叉树，其任何一非叶节点满足性质：
Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]
即任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。
堆分为大顶堆和小顶堆，满足Key[i]>=Key[2i+1]&&key>=key[2i+2]称为大顶堆，满足 Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]称为小顶堆。由上述性质可知大顶堆的堆顶的关键字肯定是所有关键字中最大的，小顶堆的堆顶的关键字是所有关键字中最小的。
2.堆排序的思想
利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，使得每次从无序中选择最大记录(最小记录)变得简单。
其基本思想为(大顶堆)：
1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；
2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];
3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
操作过程如下：
1)初始化堆：将R[1..n]构造为堆；
2)将当前无序区的堆顶元素R[1]同该区间的最后一个记录交换，然后将新的无序区调整为新的堆。
因此对于堆排序，最重要的两个操作就是构造初始堆和调整堆，其实构造初始堆事实上也是调整堆的过程，只不过构造初始堆是对所有的非叶节点都进行调整。
下面举例说明：
给定一个整形数组a[]={16,7,3,20,17,8}，对其进行堆排序。
首先根据该数组元素构建一个完全二叉树，得到
然后需要构造初始堆，则从最后一个非叶节点开始调整，调整过程如下：
即每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整)。有了初始堆之后就可以进行排序了。
这样整个区间便已经有序了。
从上述过程可知，堆排序其实也是一种选择排序，是一种树形选择排序。只不过直接选择排序中，为了从R[1...n]中选择最大记录，需比较n-1次，然后从R[1...n-2]中选择最大记录需比较n-2次。事实上这n-2次比较中有很多已经在前面的n-1次比较中已经做过，而树形选择排序恰好利用树形的特点保存了部分前面的比较结果，因此可以减少比较次数。对于n个关键字序列，最坏情况下每个节点需比较log2(n)次，因此其最坏情况下时间复杂度为nlogn。堆排序为不稳定排序，不适合记录较少的排序。
简单堆排序的例子：
以关键字序列{10，2，13，15，12，14}为例，用堆排序方法进行排序。写出每趟排序结束时，关键字序列的状态。（请按小跟堆进行排序）
首先依次输入关键字，建立堆，此时在数组的排列为
：2 10 13 15 12 14，
之后便开始每次取最小值放在堆尾，并跟新堆，每步结果依次为
：10 12 13 15 14 2
：12 14 13 15 10 2
：14 13 15 12 10 2
：14 15 13 12 10 2
：15 14 13 12 10 2
三、快速排序
设要排序的
数组是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-完成的时候，此时令循环结束）。
C#
|
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
namespacetest
{
classProgram
{
staticvoidMain(string[]args)
{
int[]array={49,38,65,97,76,13,27};
sort(array,0,array.Length-1);
Console.ReadLine();
}
private static int sortUnit(int[]array,int low,int high)
{
int key=array[low];
while(low<high)
{
while(array[high]>=key&&high>low)
--high;
array[low]=array[high];
while(array[low]<=key&&high>low)
++low;
array[high]=array[low];
}
array[low]=key;
Console.WriteLine(string.Join(",",array));
return high;
}
public static void sort(int[]array,int low,int high)
{
if(low>=high)
return;
int index=sortUnit(array,low,high);
sort(array,low,index-1);
sort(array,index+1,high);
}
}
}
|
运行结果：27 38 13 49 76 97 65
快速排序就是
递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述
数组A的快速排序的全过程如图6所示：
初始状态 {49 38 65 97 76 13 27} 进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65} 分别对前后两部分进行快速排序{27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。{76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。图示
20和16交换后导致16不满足堆的性质，因此需重新调整
这样就得到了初始堆。
此时3位于堆顶不满堆的性质，则需调整继续调整
