冒泡排序、选择排序、堆排序、快速排序、插入排序算法复杂度分析与算法实现（自己总结与转）

来源：互联网发布：excel对数据分类汇总编辑：程序博客网时间：2024/06/07 02:22

本人比较热衷于算法，也可能工作的原因，最近一直在研究算法，现将各种排序算法总结在一起，以便于查阅与使用，也希望能够帮助学习排序算法的朋友！

1、冒泡算法：
这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡：

C/C++ code

#include <iostream.h>

void BubbleSort(int* pData,int Count)

{

int iTemp;

for(int i=1;i<Count;i++)

{

for(int j=Count-1;j>=i;j--)

{

if(pData[j]<pData[j-1])

{

iTemp = pData[j-1];

pData[j-1] = pData[j];

pData[j] = iTemp;

}

void main()

{

int data[] = {10,9,8,7,6,5,4};

BubbleSort(data,7);

for (int i=0;i<7;i++)

cout<<data[i]<<" ";

cout<<"\n";

}

倒序(最糟情况)
第一轮：10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交换3次)
第二轮：7,10,9,8->7,10,8,9->7,8,10,9(交换2次)
第一轮：7,8,10,9->7,8,9,10(交换1次)
循环次数：6次
交换次数：6次

其他：
第一轮：8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交换2次)
第二轮：7,8,10,9->7,8,10,9->7,8,10,9(交换0次)
第一轮：7,8,10,9->7,8,9,10(交换1次)
循环次数：6次
交换次数：3次

上面我们给出了程序段，现在我们分析它：这里，影响我们算法性能的主要部分是循环和交换，
显然，次数越多，性能就越差。从上面的程序我们可以看出循环的次数是固定的，为1+2+...+n-1。
写成公式就是1/2*(n-1)*n。
现在注意，我们给出O方法的定义：

若存在一常量K和起点n0，使当n>=n0时，有f(n)<=K*g(n),则f(n) = O(g(n))。（呵呵，不要说没
学好数学呀，对于编程数学是非常重要的！！！）

现在我们来看1/2*(n-1)*n，当K=1/2，n0=1，g(n)=n*n时，1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n)
=O(g(n))=O(n*n)。所以我们程序循环的复杂度为O(n*n)。
再看交换。从程序后面所跟的表可以看到，两种情况的循环相同，交换不同。其实交换本身同数据源的
有序程度有极大的关系，当数据处于倒序的情况时，交换次数同循环一样（每次循环判断都会交换），
复杂度为O(n*n)。当数据为正序，将不会有交换。复杂度为O(0)。乱序时处于中间状态。正是由于这样的
原因，我们通常都是通过循环次数来对比算法。

2.选择排序法：
现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下）
这种方法类似我们人为的排序习惯：从数据中选择最小的同第一个值交换，在从省下的部分中
选择最小的与第二个交换，这样往复下去。

C/C++ code

#include <iostream.h>

void SelectSort(int* pData,int Count)

{

int iTemp;

int iPos;

for(int i=0;i<Count-1;i++)

{

iTemp = pData[i];

iPos = i;

for(int j=i+1;j<Count;j++)

{

if(pData[j]<iTemp)

{

iTemp = pData[j];

iPos = j;

}

pData[iPos] = pData[i];

pData[i] = iTemp;

}

void main()

{

int data[] = {10,9,8,7,6,5,4};

SelectSort(data,7);

for (int i=0;i<7;i++)

cout<<data[i]<<" ";

cout<<"\n";

}

倒序(最糟情况)
第一轮：10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交换1次)
第二轮：7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交换1次)
第一轮：7,8,9,10->(iTemp=9)7,8,9,10(交换0次)
循环次数：6次
交换次数：2次

其他：
第一轮：8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交换1次)
第二轮：7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交换1次)
第一轮：7,8,10,9->(iTemp=9)7,8,9,10(交换1次)
循环次数：6次
交换次数：3次
遗憾的是算法需要的循环次数依然是1/2*(n-1)*n。所以算法复杂度为O(n*n)。
我们来看他的交换。由于每次外层循环只产生一次交换（只有一个最小值）。所以f(n)<=n
所以我们有f(n)=O(n)。所以，在数据较乱的时候，可以减少一定的交换次数。

3、堆排序原理及算法实现（最大堆）

堆排序

堆排序是利用堆的性质进行的一种选择排序。下面先讨论一下堆。

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}，对其进行堆排序。

首先根据该数组元素构建一个完全二叉树，得到

然后需要构造初始堆，则从最后一个非叶节点开始调整，调整过程如下：

20和16交换后导致16不满足堆的性质，因此需重新调整

这样就得到了初始堆。

即每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整)。有了初始堆之后就可以进行排序了。

此时3位于堆顶不满堆的性质，则需调整继续调整

这样整个区间便已经有序了。

从上述过程可知，堆排序其实也是一种选择排序，是一种树形选择排序。只不过直接选择排序中，为了从R[1...n]中选择最大记录，需比较n-1次，然后从R[1...n-2]中选择最大记录需比较n-2次。事实上这n-2次比较中有很多已经在前面的n-1次比较中已经做过，而树形选择排序恰好利用树形的特点保存了部分前面的比较结果，因此可以减少比较次数。对于n个关键字序列，最坏情况下每个节点需比较log2(n)次，因此其最坏情况下时间复杂度为nlogn。堆排序为不稳定排序，不适合记录较少的排序。

测试程序

/*堆排序(大顶堆)2011.9.14*/

#include <iostream>

#include<algorithm>

usingnamespace std;

void HeapAdjust(int *a,int i,int size) //调整堆

{

int lchild=2*i; //i的左孩子节点序号

int rchild=2*i+1; //i的右孩子节点序号

intmax=i; //临时变量

if(i<=size/2) //如果i不是叶节点就不用进行调整

{

if(lchild<=size&&a[lchild]>a[max])

{

max=lchild;

}

if(rchild<=size&&a[rchild]>a[max])

{

max=rchild;

}

if(max!=i)

{

swap(a[i],a[max]);

HeapAdjust(a,max,size); //避免调整之后以max为父节点的子树不是堆

}

void BuildHeap(int *a,int size) //建立堆

{

int i;

for(i=size/2;i>=1;i--) //非叶节点最大序号值为size/2

{

HeapAdjust(a,i,size);

}

void HeapSort(int *a,int size) //堆排序

{

int i;

BuildHeap(a,size);

for(i=size;i>=1;i--)

{

//cout<<a[1]<<"";

swap(a[1],a[i]); //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面

//BuildHeap(a,i-1); //将余下元素重新建立为大顶堆

HeapAdjust(a,1,i-1); //重新调整堆顶节点成为大顶堆

}

int main(int argc,char *argv[])

{

//inta[]={0,16,20,3,11,17,8};

int a[100];

int size;

while(scanf("%d",&size)==1&&size>0)

{

int i;

for(i=1;i<=size;i++)

cin>>a[i];

HeapSort(a,size);

for(i=1;i<=size;i++)

cout<<a[i]<<" ";

cout<<endl;

}

return 0;

}

4、快速排序算法的基本特性
时间复杂度：O（n*lgn）
最坏：O（n^2）
空间复杂度：O（n*lgn）
不稳定。

快速排序是一种排序算法，对包含n个数的输入数组，平均时间为O（nlgn），最坏情况是O（n^2）。
通常是用于排序的最佳选择。因为，基于比较的排序，最快也只能达到O（nlgn）。

快速排序算法的描述
算法导论，第7章
快速排序时基于分治模式处理的，
对一个典型子数组A[p...r]排序的分治过程为三个步骤：
1.分解：
A[p..r]被划分为俩个（可能空）的子数组A[p ..q-1]和A[q+1 ..r]，使得
A[p ..q-1] <= A[q] <= A[q+1 ..r]
2.解决：通过递归调用快速排序，对子数组A[p ..q-1]和A[q+1 ..r]排序。
3.合并。

三、快速排序算法

版本一：
QUICKSORT(A, p,r)
1 if p < r
2    then q ← PARTITION(A, p, r)   //关键
3         QUICKSORT(A, p, q - 1)
4         QUICKSORT(A, q + 1, r)

数组划分
快速排序算法的关键是PARTITION过程，它对A[p..r]进行就地重排：
PARTITION(A, p, r)
1 x ← A[r]
2 i ← p - 1
3 for j ← p to r - 1
4       do if A[j] ≤ x
5             theni ← i + 1
6                 exchange A[i] <-> A[j]
7 exchange A[i + 1] <-> A[r]
8 return i + 1

ok，咱们来举一个具体而完整的例子。
来对以下数组，进行快速排序，
2 8 7 1 3 5 6 4(主元)

一、

i p/j

  2  8   7   1   3   5  6   4(主元)
j指的2<=4，于是i++，i也指到2，2和2互换，原数组不变。
j后移，直到指向1..
二、
             j（指向1）<=4，于是i++
i指向了8，所以8与1交换。
数组变成了：
i j
2   1   7   8   3  5   6   4
三、j后移，指向了3,3<=4，于是i++
i这是指向了7，于是7与3交换。
数组变成了：
i j
2   1   3   8   7  5   6   4
四、j继续后移，发现没有再比4小的数，所以，执行到了最后一步，
即上述PARTITION(A, p, r)代码部分的第7行。
因此，i后移一个单位，指向了8
i    j
2   1   3   8   7  5   6   4
A[i + 1]<-> A[r]，即8与4交换，所以，数组最终变成了如下形式，
2  1   3   4   7   5  6   8
ok，快速排序第一趟完成。
4把整个数组分成了俩部分，2 1 3,7 5 6 8，再递归对这俩部分分别快速排序。
i p/j
2   1   3(主元)
2与2互换，不变，然后又是1与1互换，还是不变，最后，3与3互换，不变，
最终，3把2 1 3，分成了俩部分，2 1，和3.
再对2 1，递归排序，最终结果成为了1 2 3.

7 5 6 8(主元)，7、5、6、都比8小，所以第一趟，还是7 5 6 8，
不过，此刻8把7 5 6 8，分成了 7 5 6，和8.[7 5 6->5 7 6->5 6 7]
再对7 5 6，递归排序，最终结果变成5 6 7 8。

5.插入排序算法描述

插入排序：插入即表示将一个新的数据插入到一个有序数组中，并继续保持有序。例如有一个长度为N的无序数组，进行N-1次的插入即能完成排序；第一次，数组第1个数认为是有序的数组，将数组第二个元素插入仅有1个有序的数组中；第二次，数组前两个元素组成有序的数组，将数组第三个元素插入由两个元素构成的有序数组中......第N-1次，数组前N-1个元素组成有序的数组，将数组的第N个元素插入由N-1个元素构成的有序数组中，则完成了整个插入排序。

以下面5个无序的数据为例：

65 27 5964 58（文中仅细化了第四次插入过程）

第1次插入: 27 65 59 64 58

第2次插入: 27 59 65 64 58

第3次插入: 27 59 64 65 58

第4次插入: 27 58 59 64 65

二.算法分析

平均时间复杂度：O(n2)

空间复杂度：O(1) (用于记录需要插入的数据)

稳定性：稳定

三.算法实现

从前向后查找的插入排序：

1. /********************************************************

2. *函数名称：InsertSort

3. *参数说明：pDataArray 无序数组；

4. * iDataNum为无序数据个数

5. *说明：插入排序

6. *********************************************************/

7. void InsertSort(int* pDataArray, int iDataNum)

8. {

9. for (int i = 1; i < iDataNum; i++) //从第2个数据开始插入

10. {

11. int j = 0;

12. while (j < i && pDataArray[j] <= pDataArray[i]) //寻找插入的位置

13. j++;

14.

15. if (j < i) //i位置之前，有比pDataArray[i]大的数，则进行挪动和插入

16. {

17. int k = i;

18. int temp = pDataArray[i];

19. while (k > j) //挪动位置

20. {

21. pDataArray[k] = pDataArray[k-1];

22. k--;

23. }

24. pDataArray[k] = temp; //插入

25. }

26. }

27. } /********************************************************

*函数名称：InsertSort

*参数说明：pDataArray 无序数组；

*      iDataNum为无序数据个数

*说明：    插入排序

*********************************************************/

void InsertSort(int* pDataArray, int iDataNum)

  for (int i = 1; i < iDataNum; i++)    //从第2个数据开始插入

   int j = 0;

   while (j < i && pDataArray[j] <= pDataArray[i])    //寻找插入的位置

     j++;

   if (j < i)    //i位置之前，有比pDataArray[i]大的数，则进行挪动和插入

     int k = i;

     int temp = pDataArray[i];

     while (k > j)    //挪动位置

      pDataArray[k] = pDataArray[k-1];

      k--;

     pDataArray[k] = temp;    //插入

但楼主发现从后面查找插入的方式，代码复杂程度较低：

[cpp]view plaincopyprint?

1. /********************************************************

2. *函数名称：InsertSort

3. *参数说明：pDataArray 无序数组；

4. * iDataNum为无序数据个数

5. *说明：插入排序

6. *********************************************************/

7. void InsertSort(int* pDataArray, int iDataNum)

8. {

9. for (int i = 1; i < iDataNum; i++) //从第2个数据开始插入

10. {

11. int j = i - 1;

12. int temp = pDataArray[i]; //记录要插入的数据

13. while (j >= 0 && pDataArray[j] > temp) //从后向前，找到比其小的数的位置

14. {

15. pDataArray[j+1] = pDataArray[j]; //向后挪动

16. j--;

17. }

18.

19. if (j != i - 1) //存在比其小的数

20. pDataArray[j+1] = temp;

21. }

22. }

/********************************************************

*函数名称：InsertSort

*参数说明：pDataArray 无序数组；

*       iDataNum为无序数据个数

*说明：    插入排序

*********************************************************/

void InsertSort(int* pDataArray, int iDataNum)

  for (int i = 1; i < iDataNum; i++)    //从第2个数据开始插入

    int j = i - 1;

    int temp = pDataArray[i];    //记录要插入的数据

    while (j >= 0 && pDataArray[j] > temp)    //从后向前，找到比其小的数的位置

      pDataArray[j+1] = pDataArray[j];    //向后挪动

      j--;

    if (j != i - 1)    //存在比其小的数

      pDataArray[j+1] = temp;

算法优化

插入排序中，总是先寻找插入位置，然后在实行挪动和插入过程；寻找插入位置采用顺序查找的方式（从前向后或者从后向前），既然需要插入的数组已经是有序的，那么可以采用二分查找方法来寻找插入位置，提高算法效率，但算法的时间复杂度仍为O(n2)。

[cpp]view plaincopyprint?

1. //查找数值iData在长度为iLen的pDataArray数组中的插入位置

2. int FindInsertIndex(int *pDataArray, int iLen, int iData)

3. {

4. int iBegin = 0;

5. int iEnd = iLen - 1;

6. int index = -1; //记录插入位置

7. while (iBegin <= iEnd)

8. {

9. index = (iBegin + iEnd) / 2;

10. if (pDataArray[index] > iData)

11. iEnd = index - 1;

12. else

13. iBegin = index + 1;

14. }

15. if (pDataArray[index] <= iData)

16. index++;

17. return index;

18. }

19.

20. /********************************************************

21. *函数名称：BinaryInsertSort

22. *参数说明：pDataArray 无序数组；

23. * iDataNum为无序数据个数

24. *说明：二分查找插入排序

25. *********************************************************/

26. void BinaryInsertSort(int* pDataArray, int iDataNum)

27. {

28. for (int i = 1; i < iDataNum; i++) //从第2个数据开始插入

29. {

30. int index = FindInsertIndex(pDataArray, i, pDataArray[i]); //二分寻找插入的位置

31.

32. if (i != index) //插入位置不为i，才挪动、插入

33. {

34. int j = i;

35. int temp = pDataArray[i];

36. while (j > index) //挪动位置

37. {

38. pDataArray[j] = pDataArray[j-1];

39. j--;

40. }

41. pDataArray[j] = temp; //插入

42. }

43. }

44. }

1 0