常用排序算法

一、冒泡排序

1.算法介紹：

冒泡排序(Bubble Sort)，又被稱爲氣泡排序或泡沫排序。

它是一種較簡單的排序算法。它會遍歷若干次要排序的數列，每次遍歷時，它都會從前往後依次的比較相鄰兩個數的大小；如果前者比後者大，則交換它們的位置。這樣，一次遍歷之後，最大的元素就在數列的末尾！ 採用相同的方法再次遍歷時，第二大的元素就被排列在最大元素之前。重複此操作，直到整個數列都有序爲止！

2.算法圖解

3.算法實現
冒泡排序C實現一

void bubble_sort1(int a[], int n)
{
    int i,j;

    for (i=n-1; i>0; i--)
    {
        // 將a[0...i]中最大的數據放在末尾
        for (j=0; j<i; j++)
        {
            if (a[j] > a[j+1])
                swap(a[j], a[j+1]);
        }
    }
}

冒泡排序C實現二：

void bubble_sort2(int a[], int n)
{
    int i,j;
    int flag;                 // 標記

    for (i=n-1; i>0; i--)
    {
        flag = 0;            // 初始化標記爲0

        // 將a[0...i]中最大的數據放在末尾
        for (j=0; j<i; j++)
        {
            if (a[j] > a[j+1])
            {
                swap(a[j], a[j+1]);
                flag = 1;    // 若發生交換，則設標記爲1
            }
        }

        if (flag==0)
            break;            // 若沒發生交換，則說明數列已有序。
    }
}

二、快速排序

1.算法介紹：

快速排序(Quick Sort)使用分治法策略。

它的基本思想是：選擇一個基準數，通過一趟排序將要排序的數據分割成獨立的兩部分；其中一部分的所有數據都比另外一部分的所有數據都要小。然後，再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

快速排序流程：

• 從數列中挑出一個基準值。
• 將所有比基準值小的擺放在基準前面，所有比基準值大的擺在基準的後面(相同的數可以到任一邊)；在這個分區退出之後，該基準就處於數列的中間位置。
• 遞歸地把”基準值前面的子數列”和”基準值後面的子數列”進行排序。

2.算法圖解

3.算法實現

/*
 * 快速排序
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     l -- 數組的左邊界(例如，從起始位置開始排序，則l=0)
 *     r -- 數組的右邊界(例如，排序截至到數組末尾，則r=a.length-1)
 */
void quick_sort(int a[], int l, int r)
{
    if (l < r)
    {
        int i,j,x;

        i = l;
        j = r;
        x = a[i];
        while (i < j)
        {
            while(i < j && a[j] > x)
                j--; // 從右向左找第一個小於x的數
            if(i < j)
                a[i++] = a[j];
            while(i < j && a[i] < x)
                i++; // 從左向右找第一個大於x的數
            if(i < j)
                a[j--] = a[i];
        }
        a[i] = x;
        quick_sort(a, l, i-1); /* 遞歸調用 */
        quick_sort(a, i+1, r); /* 遞歸調用 */
    }
}

三、選擇排序

1.算法介紹：

選擇排序(Selection sort)是一種簡單直觀的排序算法。

它的基本思想是：首先在未排序的數列中找到最小(or最大)元素，然後將其存放到數列的起始位置；接着，再從剩餘未排序的元素中繼續尋找最小(or最大)元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

2.算法圖解

3.算法實現

/*
 * 選擇排序
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     n -- 數組的長度
 */
void select_sort(int a[], int n)
{
    int i;        // 有序區的末尾位置
    int j;        // 無序區的起始位置
    int min;    // 無序區中最小元素位置

    for(i=0; i<n; i++)
    {
        min=i;

        // 找出"a[i+1] ... a[n]"之間的最小元素，並賦值給min。
        for(j=i+1; j<n; j++)
        {
            if(a[j] < a[min])
                min=j;
        }

        // 若min!=i，則交換 a[i] 和 a[min]。
        // 交換之後，保證了a[0] ... a[i] 之間的元素是有序的。
        if(min != i)
            swap(a[i], a[min]);
    }
}

四、直接插入排序

1.算法介紹：

直接插入排序(Straight Insertion Sort)的基本思想是：把n個待排序的元素看成爲一個有序表和一個無序表。開始時有序表中只包含1個元素，無序表中包含有n-1個元素，排序過程中每次從無序表中取出第一個元素，將它插入到有序表中的適當位置，使之成爲新的有序表，重複n-1次可完成排序過程。

2.算法圖解

3.算法實現

/*
 * 直接插入排序
 *
 * 參數說明：
 *     a -- 待排序的數組
 *     n -- 數組的長度
 */
void insert_sort(int a[], int n)
{
    int i, j, k;

    for (i = 1; i < n; i++)
    {
        //爲a[i]在前面的a[0...i-1]有序區間中找一個合適的位置
        for (j = i - 1; j >= 0; j--)
            if (a[j] < a[i])
                break;

        //如找到了一個合適的位置
        if (j != i - 1)
        {
            //將比a[i]大的數據向後移
            int temp = a[i];
            for (k = i - 1; k > j; k--)
                a[k + 1] = a[k];
            //將a[i]放到正確位置上
            a[k + 1] = temp;
        }
    }
}

注：更多算法請看這裏——數據結構與算法系列 目錄，以上算法皆來至於這裏。