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



   本人比较热衷于算法，也可能工做的缘由，最近一直在研究算法，现将各类排序算法总结在一块儿，以便于查阅与使用，也但愿可以帮助学习排序算法的朋友！

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

C/C++ code

?

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

#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

?

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

#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>

using namespace 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.合并。

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(主元)

1、

i p/j

  2  8   7   1   3   5  6   4(主元)
j指的2<=4，因而i++，i也指到2，2和2互换，原数组不变。
j后移，直到指向1..
2、
             j（指向1）<=4，因而i++
i指向了8，因此8与1交换。
数组变成了：
       i          j
  2   1   7   8   3  5   6   4
3、j后移，指向了3,3<=4，因而i++
i这是指向了7，因而7与3交换。
数组变成了：
             i         j
  2   1   3   8   7  5   6   4
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.  }