冒泡排序、選擇排序、堆排序、快速排序、插入排序算法複雜度分析與算法實現（本身總結與轉）



   本人比較熱衷於算法，也可能工做的緣由，最近一直在研究算法，現將各類排序算法總結在一塊兒，以便於查閱與使用，也但願可以幫助學習排序算法的朋友！

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.  }