排序和查找算法--C

冒泡排序算法及代碼

“冒泡”由來是因爲越大的元素會經由交換慢慢“浮”到數列的頂端，故名。這裏以從小到大排序爲例進行講解。

基本思想及舉例說明

基本思想：不斷比較相鄰的兩個數，讓較大的元素後移。經過一輪比較，就選出最大的數；經過第2輪比較，就選出次大的數，以此類推。

下面對3 2 4 1進行冒泡排序。
第一輪 排序過程

3 2 4 1 （最初）
2 3 4 2 （比較3和2之後，交換）
2 3 4 1 （比較3和4之後，不交換）
2 3 1 4 （比較4和1之後，交換）

第一輪結束，最大的數4已經在最後面，因此第二輪排序只需要對前面三個數進行再比較。

第二輪 排序過程

2 3 1 4 （第一輪排序結果）
2 3 1 4 （比較2和3，不交換）
2 1 3 4 （比較3和1，交換)

第二輪結束，第二大的數已經排在倒數第二個位置，所以第三輪只需要比較前兩個元素。

第三輪 排序過程

2 1 3 4 （第二輪排序結果）
1 2 3 4 （比較2和1，交換）

至此，排序結束。

算法總結及實現

對於具有N個元素的數組R[n]，進行最多N-1輪比較；

第一輪，逐個比較（R[1], R[2]）, （R[2], R[3]）, （R[3], R[4]）, ……. （R[N-1], R[N]） ; 最大的元素會被移動到R[N]上。

第二輪，逐個比較（R[1], R[2]）, （R[2], R[3]）, （R[3], R[4]）, ……. （R[N-2], R[N-1]）；第二大元素會被移動到R[N-1]上。
第三輪，。。。

以此類推，直到整個數組從小到大排序。

下面給出了冒泡排序的一般實現和優化實現。一般實現是教科書裏常見的實現方法，無論數組是否排序好了，都會進行N-1輪比較； 而優化實現，在數組已經排序好的情況下，會提前退出比較，減小了算法的時間複雜度。

#include<stdio.h>
#include<stdlib.h>
#define N 8
void bubble_sort(int a[],int n);
//一般實現
void bubble_sort(int a[],int n)//n爲數組a的元素個數
{
    //一定進行N-1輪比較
    for(int i=0; i<n-1; i++)
    {
        //每一輪比較前n-1-i個，即已排序好的最後i個不用比較
        for(int j=0; j<n-1-i; j++)
        {
            if(a[j] > a[j+1])
            {
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1]=temp;
            }
        }
    }
}

int  main()
{
    int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};
    bubble_sort(num, N); //或者使用bubble_sort_better(num, N);
    for(int i=0; i<N; i++)
        printf("%d  ", num[i]);
    printf("\n");
    system("pause");
    return 0;
}

//優化實現
#include<stdio.h>
#include<stdbool.h>//C99標準裏面，重新定義了bool類型變量。需要引入頭文件 <stdbool.h>，就能在C語言裏面正常使用bool類型。
#include<stdlib.h>
#define N 8
void bubble_sort_better(int a[],int n)//n爲數組a的元素個數
{
    //最多進行N-1輪比較
    for(int i=0; i<n-1; i++)
    {
        bool isSorted = true;
        //每一輪比較前n-1-i個，即已排序好的最後i個不用比較
        for(int j=0; j<n-1-i; j++)
        {
            if(a[j] > a[j+1])
            {
                isSorted = false;
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1]=temp;
            }
        }
        if(isSorted) break; //如果沒有發生交換，說明數組已經排序好了
    }
}
int  main()
{
    int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};
    bubble_sort(num, N); //或者使用bubble_sort_better(num, N);
    for(int i=0; i<N; i++)
        printf("%d  ", num[i]);
    printf("\n");
    system("pause");
    return 0;
}

選擇排序算法及代碼

基本思想及舉例說明

基本思想:首先，選出最小的數，放在第一個位置；然後，選出第二小的數，放在第二個位置；以此類推，直到所有的數從小到大排序。(以由小到大舉例)
在實現上，我們通常是先確定第i小的數所在的位置，然後，將其與第i個數進行交換。
下面，以對 3 2 4 1 進行選擇排序說明排序過程，使用min_index 記錄當前最小的數所在的位置。

第1輪 排序過程 （尋找第1小的數所在的位置）

3 2 4 1（最初， min_index=1）
3 2 4 1（3 > 2， 所以min_index=2）
3 2 4 1（2 < 4， 所以 min_index=2）
3 2 4 1（2 > 1， 所以 min_index=4， 這時候確定了第1小的數在位置4）
1 2 4 3 （第1輪結果，將3和1交換，也就是位置1和位置4交換）

第2輪 排序過程 （尋找第2小的數所在的位置）

1 2 4 3（第1輪結果， min_index=2，只需要從位置2開始尋找）
1 2 4 3（4 > 2， 所以min_index=2）
1 2 4 3（3 > 2， 所以 min_index=2）
1 2 4 3（第2輪結果，因爲min_index位置剛好在第2個位置，無需交換）

第3輪 排序過程 （尋找第3小的數所在的位置）

1 2 4 3（第2輪結果， min_index=3，只需要從位置2開始尋找）
1 2 4 3（4 > 3， 所以min_index=4）
1 2 3 4（第3輪結果，將3和4交換，也就是位置4和位置3交換）

至此，排序完畢。

算法總結及實現

選擇排序對大小爲N的無序數組R[N]進行排序，進行N-1輪選擇過程。第i輪選取第i小的數，並將其放在第i個位置上。當第N-1次完成時，第N小（也就是最大）的數自然在最後的位置上。

#include<stdio.h>
#include<stdlib.h>
#define N 8
void select_sort(int a[],int n);
//選擇排序實現
void select_sort(int a[],int n)//n爲數組a的元素個數
{
    //進行N-1輪選擇
    for(int i=0; i<n-1; i++)
    {
        int min_index = i; 
        //找出第i小的數所在的位置
        for(int j=i+1; j<n; j++)
        {
            if(a[j] < a[min_index])
            {
                min_index = j;
            }
        }
        //將第i小的數，放在第i個位置；如果剛好，就不用交換
        if( i != min_index)
        {
            int temp = a[i];
            a[i] = a[min_index];
            a[min_index] = temp;
        }
    }
}
int  main()
{
    int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};
    select_sort(num, N);
    for(int i=0; i<N; i++)
        printf("%d  ", num[i]);
    printf("\n");
    system("pause");
    return 0;
}

注意：選擇排序是一種不穩定的排序算法，可能會打亂兩個相同數字的原有順序。

例如，序列 5 8 5 2 9， 按照從小到大排序，第一輪會將第1個數字5會和2交換，那麼原序列中2個5的相對前後順序就被破壞了，所以選擇排序是一種不穩定的排序算法。

插入排序算法及代碼

插入排序是排序算法的一種，它不改變原有的序列（數組），而是創建一個新的序列，在新序列上進行操作。
這裏以從小到大排序爲例進行講解。

基本思想及舉例說明

插入排序的基本思想是，將元素逐個添加到已經排序好的數組中去，同時要求，插入的元素必須在正確的位置，這樣原來排序好的數組是仍然有序的。

在實際使用中，通常是排序整個無序數組，所以把這個無序數組分爲兩部分排序好的子數組和待插入的元素。第一輪時，將第一個元素作爲排序好的子數組，插入第二個元素；第二輪，將前兩個元素作爲排序好的數組，插入第三個元素。以此類推，第i輪排序時，在前i個元素的子數組中插入第i+1個元素。直到所有元素都加入排序好數組。
下面，以對 3 2 4 1 進行選擇排序說明插入過程，使用j記錄元素需要插入的位置。排序目標是使數組從小到大排列。

第1輪

[ 3 ] [ 2 4 1 ] （最初狀態，將第1個元素分爲排序好的子數組，其餘爲待插入元素）
[ 3 ] [ 2 4 1 ] （由於3>2，所以待插入位置j=1）
[ 2 3 ] [ 4 1 ] （將2插入到位置j）

第2輪

[ 2 3 ] [ 4 1 ] （第1輪排序結果）
[ 2 3 ] [ 4 1 ] （由於2<4，所以先假定j=2）
[ 2 3 ] [ 4 1 ] （由於3<4，所以j=3）
[ 2 3 4 ] [ 1 ] （由於4剛好在位置3，無需插入）

第3輪

[ 2 3 4 ] [ 1 ] （第2輪排序結果）
[ 2 3 4 ] [ 1 ] （由於1<2，所以j=1）
[1 2 3 4 ] （將1插入位置j，待排序元素爲空，排序結束）

算法總結及實現

選擇排序對大小爲N的無序數組R[N]進行排序，進行N-1輪選擇過程。首先將第1個元素作爲已經排序好的子數組，然後將剩餘的N-1個元素，逐個插入到已經排序好子數組；。因此，在第 i輪排序時，前i個元素總是有序的，將第i+1個元素插入到正確的位置。

#include<stdio.h>
#include<stdlib.h>
#define N 8
void insert_sort(int a[],int n);
//插入排序實現,這裏按從小到大排序
void insert_sort(int a[],int n)//n爲數組a的元素個數
{
    //進行N-1輪插入過程
    for(int i=1; i<n; i++)
    {
        //首先找到元素a[i]需要插入的位置
        int j=0;
        while( (a[j]<a[i]) && (j<i))
        {
            j++;
        }
        //將元素插入到正確的位置
        if(i != j)  //如果i==j，說明a[i]剛好在正確的位置
        {
            int temp = a[i];
            for(int k = i; k > j; k--)
            {
                a[k] = a[k-1];
            }
            a[j] = temp;
        }
    }
}
int  main()
{
    int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};
    insert_sort(num, N);
    for(int i=0; i<N; i++)
        printf("%d  ", num[i]);
    printf("\n");
    system("pause");
    return 0;
}

注意：插入排序是一種穩定的排序算法，不會改變原有序列中相同數字的順序。

插入排序是在一個已經有序的小序列的基礎上，一次插入一個元素。當然，剛開始這個有序的小序列只有1個元素，就是第一個元素。比較是從有序序列的末尾開始，也就是想要插入的元素和已經有序的最大者開始比起，如果比它大則直接插入在其後面，否則一直往前找直到找到它該插入的位置。如果碰見一個和插入元素相等的，那麼插入元素把想插入的元素放在相等元素的後面。所以，相等元素的前後順序沒有改變，從原無序序列出去的順序就是排好序後的順序，所以插入排序是穩定的。

快速排序算法及代碼

快速排序是對冒泡法排序的一種改進。
快速排序算法 的基本思想是：將所要進行排序的數分爲左右兩個部分，其中一部分的所有數據都比另外一 部分的數據小，然後將所分得的兩部分數據進行同樣的劃分，重複執行以上的劃分操作，直 到所有要進行排序的數據變爲有序爲止。

可能僅根據基本思想對快速排序的認識並不深，接下來以對n個無序數列A[0], A[1]…, A[n-1]採用快速排序方法進行升序排列爲例進行講解。

(1)定義兩個變量low和high，將low、high分別設置爲要進行排序的序列的起始元素和最後一個元素的下標。第一次，low和high的取值分別爲0和n-1，接下來的每次取值由劃分得到的序列起始元素和最後一個元素的下標來決定。

(2)定義一個變量key，接下來以key的取值爲基準將數組A劃分爲左右兩個部分，通 常，key值爲要進行排序序列的第一個元素值。第一次的取值爲A[0]，以後毎次取值由要劃 分序列的起始元素決定。

(3)從high所指向的數組元素開始向左掃描，掃描的同時將下標爲high的數組元素依次與劃分基準值key進行比較操作，直到high不大於low或找到第一個小於基準值key的數組元素，然後將該值賦值給low所指向的數組元素，同時將low右移一個位置。

(4)如果low依然小於high，那麼由low所指向的數組元素開始向右掃描，掃描的同時將下標爲low的數組元素值依次與劃分的基準值key進行比較操作，直到low不小於high或找到第一個大於基準值key的數組元素，然後將該值賦給high所指向的數組元素，同時將high左移一個位置。

(5)重複步驟(3) (4)，直到low的植不小於high爲止，這時成功劃分後得到的左右兩部分分別爲A[low……pos-1]和A[pos+1……high]，其中，pos下標所對應的數組元素的值就是進行劃分的基準值key，所以在劃分結束時還要將下標爲pos的數組元素賦值 爲 key。

(6)將劃分得到的左右兩部分A[low……pos-1]和A[pos+1……high]繼續採用以上操作步驟進行劃分，直到得到有序序列爲止。

爲了能夠加深讀者的理解，接下來通過一段代碼來了解快速排序的具體實現方法。
在上面的代碼中，根據前面介紹的步驟一步步實現了快速排序算法。接下來通過示意圖來演示第一次劃分操作。

在第一次劃分操作中，先進行初始設置，key的值是進行劃分的基準，其值爲要劃分數 組的第一個元素值，在上面的排序序列中爲第一個元素值32，同時將low設置爲要排序數組中第一個元素的下標，第一次排序操作時其值爲0，將high設置爲要排序序列最後一個 元素的下標，在上面的排序序列中其第一次取值爲5。先將下標爲high的數組元素與key進行比較，由於該元素值大於key，因此high向左移動一個位置繼續掃描。由於接下來的值爲 23，小於key的值，因此將23賦值給下標爲low所指向的數組元素。接下來將low右移一 個位置，將low所指向的數組元素的值與key進行比較，由幹接下來的12、7都小於key， 因此low繼續右移掃描，直至下標low所指向的數組元素的值爲78即大於key爲止，將78賦值給下標爲high所指向的數組元素，同時將high左移一個位置。接下來由於low不再小於high，劃分結束。需要注意的是，在進行劃分的過程中，都是將掃描的值與key的值進行對比，如果小於key，那麼將該值賦值給數組中的另外一個元素，而該元素的值並沒有改變。 從圖中可以看出這一點，所以需要在劃分的最後將作爲劃分基準的key值賦值給下標爲 pos的數組元素，這個元素不再參與接下來的劃分操作。

第一輪劃分結束後，得到了左右兩部分序列A[0]、A[1]、A[2]和A[4]、A[5]，繼續進 行劃分，即對毎輪劃分後得到的兩部分序列繼續劃分，直至得到有序序列爲止。

歸併排序(合併排序)算法及代碼

歸併排序也稱合併排序，其算法思想是將待排序序列分爲兩部分，依次對分得的兩個部分再次使用歸併排序，之後再對其進行合併。僅從算法思想上了解歸併排序會覺得很抽象，接下來就以對序列A[0], A[l]…, A[n-1]進行升序排列來進行講解，在此採用自頂向下的實現方法，操作步驟如下。

(1)將所要進行的排序序列分爲左右兩個部分，如果要進行排序的序列的起始元素下標爲first，最後一個元素的下標爲last，那麼左右兩部分之間的臨界點下標mid=(first+last)/2，這兩部分分別是A[first … mid]和A[mid+1 … last]。

(2)將上面所分得的兩部分序列繼續按照步驟(1)繼續進行劃分，直到劃分的區間長度爲1。

(3)將劃分結束後的序列進行歸併排序，排序方法爲對所分的n個子序列進行兩兩合併，得到n/2或n/2+l個含有兩個元素的子序列，再對得到的子序列進行合併，直至得到一個長度爲n的有序序列爲止。下面通過一段代碼來看如何實現歸併排序。
分析上面的運行結果，通過歸併排序成功地實現了對給定序列的排序操作。接下來通過下圖來了解歸併排序的具體操作流程。

在上圖中，先對所要進行排序的序列進行分解，直到分爲單個元素爲止，然後將其進行兩兩合併。由於最終分解成單個元素，因此在合併的時候.將小數放在前面，大數放在後面，得到一個有序序列。接下來對兩個相連的有序序列進行排序，先比較有序序列中的第一個元素，將較小的元素放入臨時數組中，接着將較小元素所在數組的下一個元素與另一個數組中的較小元素比較，同樣將較小元素放入臨時數組中，依次進行，直到兩個數組的所有元素都放入臨時數組中，最後再將臨時數組的元素放入原始數組中的對應位置。

歸併排序的操作流程

順序查找算法及代碼

順序査找是一種簡單的査找算法，其實現方法是從序列的起始元素開始，逐個將序列中的元素與所要查找的元素進行比較，如果序列中有元素與所要查找的元素相等，那麼査找成功，如果査找到序列的最後一個元素都不存在一個元素與所要査找的元素值相等，那麼表明査找失敗。接下來通過一段代碼來了解順序査找的具體使用。

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
int ordersearch(int a[], int n, int des){
    int i;
    for(i=0; i<n; i++)
        if(des==a[i])
            return 1;
    return 0;
}
int main(){
    int i, val;
    int a[8] = {32,12,56,78,76,45,43,98};
    int ret;
    for(i=0; i<8; i++)
        printf("%d\t", a[i]);

    printf("\n請輸入所要查找的元素：");
    while(1){
        scanf("%d", &val);
        fflush(stdin);
        ret = ordersearch(a, 8, val);
        if(1 == ret)
            printf ("查找成功！");
        else
            printf ("查找失敗！");
        printf("\n請輸入所要查找的元素：");
    }
    return 0;
}

二分查找(折半查找)算法及代碼

二分査找也稱折半査找，其優點是查找速度快，缺點是要求所要査找的數據必須是有序序列。該算法的基本思想是將所要査找的序列的中間位置的數據與所要査找的元素進行比較，如果相等，則表示査找成功，否則將以該位置爲基準將所要査找的序列分爲左右兩部分。接下來根據所要査找序列的升降序規律及中間元素與所查找元素的大小關係，來選擇所要査找元素可能存在的那部分序列，對其採用同樣的方法進行査找，直至能夠確定所要查找的元素是否存在，具體的使用方法可通過下面的代碼具體瞭解。

#include <stdio.h>
binarySearch(int a[], int n, int key){
    int low = 0;
    int high = n - 1;
    while(low<= high){
        int mid = (low + high)/2;
        int midVal = a[mid];
        if(midVal<key)
            low = mid + 1;
        else if(midVal>key)
            high = mid - 1;
        else
            return mid;
    }
    return -1;
}
int main(){
    int i, val, ret;
    int a[8]={-32, 12, 16, 24, 36, 45, 59, 98};
    for(i=0; i<8; i++)
        printf("%d\t", a[i]);
    printf("\n請輸人所要查找的元素：");
    scanf("%d",&val);
    ret = binarySearch(a,8,val);
    if(-1 == ret)
        printf("查找失敗 \n");
    else
        printf ("查找成功 \n");
    return 0;
}

在上面的代碼中，我們成功地通過二分査找算法實現了查找功能，其實現過程如下圖所示。

二分査找算法的査找過程
在如上圖所示的查找過程中，先將序列中間位置的元素與所要査找的元素進行比較，發現要査找的元素位幹該位置的左部分序列中。接下來將mid的左邊一個元素作爲 high，繼續進行二分査找，這時mid所對應的中間元素剛好是所要査找的元素，査找結束，返回査找元素所對應的下標。在main函數中通過返回值來判斷査找是否成功，如果査找成功.就打印輸出“査找成功”的信息，否則輸出“査找失畋”的信息。

本文並非本人全部原創，參考了以下的內容，並進行整理得到。其中，所有的程序都是經過了實際運行驗證。
參考