交換排序

所謂交換，就是根據序列中兩個記錄鍵值的比較結果來對換這兩個記錄在序列中的位置，交換排序的特點是：將鍵值較大的記錄向序列的尾部移動，鍵值較小的記錄向序列的前部移動。

排序入門之冒泡排序

冒泡排序是典型的交換排序算法。冒泡排序的時間復雜度為O(n²)，可以說效率比較低，但是，冒泡排序體現的思想是學習排序算法很好的入門，尤其是對學習快速排序（在冒泡排序基礎之上發展起來的）很有幫助。

基本思想

冒泡排序的基本思想是，進行（最多進行）n-1趟冒泡，其中n為數據的個數，其中每次冒泡會將未排序的最大的值移動到未排序序列的末尾，冒泡的方式是從左到有依次兩兩比較，並將值較大的交換到右側，將值較小的移動到左側。這樣每趟冒泡都會將一個最大值（未排序的部分）放到正確的位置上。

優化

可以對冒泡排序進行優化：當一趟冒泡過程中，沒有發生值交換，說明整個序列已經有序，這個時候我們就退出外層循環，排序結束。

源代碼

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

void bubble_sort(int value[],int n)
{
    int i = 0;
    for(;i < n - 1;i++)//n-1趟
    {
        int j = 0;
        
 
bool tag = false;
        for(;j < n-i-1;j++)//依次進行兩兩比較
        {
            if(value[j] > value[j+1])
            {
                tag = true;//存在交換
                int temp = value[j];
                value[j] = value[j + 1];
                value[j + 1] = temp;
            }
        }
        
 
if(!tag)//不存在交換，說明已經有序，退出循環
            break;

    }
    printf("進行了%d趟排序\n",i);
}
int main()
{
    int value[] = {8,6,3,7,4,5,1,2,10,9};
    int n = 10;
    bubble_sort(value,n);
    printf("排序結果為：\n");
    int i = 0;
    for(;i < n;i++)
    {
        printf("%d  ",value[i]);
    }
    printf("\n");
    return 0;
}

快速排序

對於包含n個數的輸入數組來說，快速排序是一種最壞情況時間復雜度為O(n²)的排序算法。雖然最壞情況時間復雜度很差，但是快排序通常是實際排序應用中最好的選擇，因為它的平均性能非常好，它的期望時間復雜度是O(nlgn)，而且常量因子非常小。

快速排序是實際中最常用的一種排序算法，速度快，效率高。就像名字一樣，快速排序是最優秀的一種排序算法。

基本思想

快速排序的思想是典型的分治思想，而分治思想大多和遞歸是分不開的。

分治思想的重要三個步驟是，分解、解決、合並

分解：

將原問題分解成若幹子問題，這些子問題是原問題的規模較小的實例。

解決：

遞歸地求解這些子問題，如果子問題的規模較小，則直接求解。

合並：

合並這些子問題的解以求得原問題的解。

具體到快速排序算法上，分治思想是這樣體現的。

分解：

將數組 A[p…r]劃分成兩個子數組A[p….q-1]和A[q+1….r]，其中A[p….q-1]中的元素都不大於A[q]，A[q+1….r]中的元素都不小於A[q].

解決：

通過遞歸調用快速排序，對子數組A[p….q-1]和A[q+1….r]進行排序，當子數組為空，或者只有一個元素的時候，就不需要再遞歸解決了（這就是問題規模足夠小的時候，直接解決）

合並：

由於子數組都是原地址排序，所以子數組有序後，原數組就有序了，不需要額外的合並處理了。

具體細節

從上面快速排序的分治思想三個步驟來看，最關鍵的就是第一步分解了，而分解中最關鍵的就是確定q了。下面我們來仔細說說如何確定q。

確定q的方法是這樣的：

首先找一個主元（pivot element），然後設置兩個哨兵，哨兵i和哨兵j，哨兵i指向首元素，j指向尾元素，哨兵j從後往前，哨兵i從前往後。我們要達到的目的是這樣的：比主元大的元素都在主元的後面，比主元小的元素都在主元的前面。為了達到這個目的，我們首先比較pivot和A[j]的大小，如果A[j]大於pivot，那麽A[j]不必移動，這時候哨兵j向前移動，也就是j--，知道找到A[j]小於pivot，停下來。然後比較pivot和A[i]，同樣，找到A[i]大於pivot停下來（不過i是向後移動），然後交換此時的A[i]和A[j]，這樣大的值就到後面去了，小的值就到前面去了。然後重復這個過程，直到兩個哨兵相遇，也就是i=j。你可能會問：為什麽是從j開始，而不是從i開始呢？這和你選擇的pivot的位置有關系，其實從i和j開始都是可以的，不過分情況看，其中一種會簡化步驟。這個我們後面再討論。最後i=j後，還要安排pivot的位置，至於怎麽安排我們後面講。

實例解析如何確定q（也就是比A[p…q-1]中元素都大，比A[q+1…r]中元素都小的那個值的下標）

下面我們通過一個實例來講解如何找到q

有這樣一個序列：

1、 假設我們選擇的pivot是8，pivot這個東西是隨便選的（也不是，一個壞的pivot會影響快速排序的效率，不過那是後話，是優化的問題了）。之所以選擇8，是因為選在兩端處理起來比較容易（後面會講為什麽，也會隨便選一個pivot）。

哨兵i指向8，j指向9，如下圖

2、 然後，我們先j開始，從後往前，找到比8小的值停下，也就是j停在0的位置（至於為什麽先從j開始，後面再講）

3、 然後我們再從i開始，找到比8大的值停下，我們發現知道i=j也沒發現比8大的值，前面我們也說過，哨兵相遇的時候要終止，所以有

本來是要有i和j的值進行交換的，然後要重復執行2,3過程，直到i=j，因為我這個序列選的不是特別好，第一次就到i=j了（沒關系，後面我們會隨機選擇一個pivot），這個時候我們要退出循環，然後安排pivot的位置。對於這種pivot選擇在最左邊，而且先從j開始的情況，直接交換8和i處的值（也是j處的值），然後返回i，就是我們所要求的q。分解成的兩個子數組就是[0,6,3,7,4,5,1,2]和[9]。然後再對這兩個數組遞歸排序。

註意，直接交換的前提是，pivot選擇了最左側的值，而且每一次是從後端（j端）開始。不同的pivot選擇方式、從i開始還是從j開始會影響最後pivot的分配方式。下面我們分幾種情況看。

上面我們從j端開始，那麽下面我們從i開始會看看會怎樣。

首先我們依然選擇最左端的8為pivot，i指向最左端，j指向最右端，如圖

然後我們從左端開始（i）開始，一直向後，直到找到大於8的值，最後找到了9，這是i和j也相遇了。

哨兵相遇後，我們要分配pivot，在上一種情況下，我們是直接交換了i處的值和8，但是這次我們如果直接交換i處的值，然後返回i作為我們所求得的q，結果就是錯誤的。

那麽正確的做法是怎樣的呢？應該是交換9左邊的0和pivot，也就是交換0和8

為什麽會造成這種結果呢？前面說過，最後pivot的分配問題，與兩點有關，一是pivot的選擇方式，二是從i端還是從j端開始的。Pivot選擇在最左端，我們要註意最左端這個位置很特殊，特殊之處就在於：這個位置最終一定是要放置比pivot小的值，除非A[p…q+1]這個子數組為空（此時該處就應該放置pivot），想想看是不是這樣。那麽先從i開始和先從j開始又有什麽區別呢？我們要註意從i開始是找大於pivot的值然後停下，而從j開始是找小於pivot的值然後停下來，所以如果先從i開始，當i和j相遇時，相遇處的值一定是大於pivot的（就像9）。相反，如果從j開始，相遇處的值一定是小於pivot的（比如第一種情況的0）。當相遇處的值小於pivot時，直接交換pivot和相遇處的值即可。但是如果相遇處的值大於pivot時，這個時候不能直接交換，直接交換就不滿足條件了，應該交換pivot和相遇處前一位的值。

接下來，我們選擇一個不在最左端的pivot，比如我們選擇4。

這次我們選擇先從i開始，向後找到比4大的值然後停下，停在了8處。然後從j開始，向前找到比4小的值，停在了0處。

交換i處和j處的值

然後開始下一輪，即再次從i開始找到比4大的數，停下，停在了6處；然後從j開始向前找比4小的數，停在了2處.

交換i處和j處的值。

接著開始下一輪，從i開始，停在了7處，從j開始停在了1處

交換i和j處的值

然後開始下一輪，從i處向後，停在了5處，然後從j開始找小於4的值，當到5處時，j和i相遇。相遇了我們就要分配pivot的值

我們發現相遇處的值5比pivot（4）要大，所以這個時候我們要交換4和5前面一位（也就是4）的值，這個整好（巧了）pivot就是5的前一位，所以不用交換。然後我們返回i-1，就是我們求得的q。分解成的兩個數組就是[0,2,3,1]和[5,7,6,8,9]

我們就一直寫下去吧，我們先對[0,2,3,1]求解

為了最後分配pivot簡單，我們就選最左側的值為pivot，然後每次都從j開始。

從j開始向前，找小於0的值，停在了0處，和i相遇，交換相遇處的值（0）和pivot（0）（是同一個）

返回i的值，就是我們求得的q，兩個子數組為，[]和[2,3,1]

然後我們處理[2,3,1]

從j開始，停在1處，再從i開始停在3處

值交換

然後開始新一輪，從j開始，遇到了i停下，分配pivot

交換pivot和i處的值

返回i，就是求得的q，兩個數組為[1]和[3]，都只有一個值結束。

回過頭來，我們解決[7,6,8,9]

相信你早已經明白了，，，，，不寫了。。。。。

最後給出代碼

#include <stdio.h>

#include <stdlib.h>

 

int partition(int value[], int start, int end)

{

         int pivot = value[start];//pivot選擇最左端的值

         int i = start;

         int j = end;

         while(i != j)

         {

                  if(value[j] >= pivot )//先從j開始

                  {

                          j--;

                          continue;

                  }

                  if(value[i] <= pivot)

                  {

                          i++;

                          continue;

                  }

                  //交換i處和j處的值

                  int temp = value[i];

                  value[i] = value[j];

                  value[j] = temp;

 

         }

         //交換pivot和相遇處的值

         int temp = value[start];

         value[start] = value[i];

         value[i] = temp;

 

         //返回相遇處的下標

         return i;

 

 

}

void quick_sort(int value[],int start,int end)

{

         if(end - start + 1 <= 1)//當數組為空或只有一個元素時，不用排序了

                  return;

 

         int q = partition(value,start,end);//找到q

 

         //遞歸求解分解成的兩個子數組

         quick_sort(value,start,q-1);

         quick_sort(value,q+1,end);

 

}

 

 

int main()

{

         int value[] = {8,6,3,7,4,5,1,2,0,9};

         int n = 10;

         quick_sort(value,0,9);

         printf("排序結果為：\n");

         int i = 0;

         for(;i < n;i++)

         {

                  printf("%d  ",value[i]);

         }

         printf("\n");

         return 0;

}

最後附上word文檔和源代碼文件

鏈接：http://pan.baidu.com/s/1slLkPFf 密碼：mnoi

如果你覺得對你有用，請點個贊吧~~~

交換排序之冒泡排序和快速排序