幾種快速排序的實現(C語言描述)

　　快速排序是對冒泡排序的改進，主要思想是通過一次排序將序列分成兩部分，左邊的部分全部小於基准值，右邊的部分大於基准值。在這一思想下，有不同的幾種實現方式。

(以下代碼中的測試數據來自用系統時間做種的隨機生成序列)

(除了以下版本，還有一些其他的快排的想法。)

1. 比較好理解的版本

/*
 *2012年2月13日11:28:00
 *quickSort
 *這個版本是比較好理解的版本(效率不是最高的)
 *quickSort函數第二個參數是要排序的數組起始下標，第三個參數是結束下標
 *過程：
 *1. 將最左邊的數設為val(也即關鍵字)
 *2. 從i開始向右找比val大的數，找到后停下
 *3. 從j開始向左找比val小的數，找到后停下
 *4. 如果i>=j則離開循環
 *5. 否則：交換當前的兩個數
 *6. 對左邊遞歸
 *7. 對右邊遞歸
 */

#include <stdio.h>
#include <time.h>

#define MAX 10
#define SWAP(x, y) {int t=x; x=y; y=t;}

void quickSort(int *a, int left, int right);

int main(void)
{
    int a[MAX] = {0};
    int i;

    srand(time(NULL));

    printf("排序前:\n");
    for (i=0; i<MAX; i++)
    {
        a[i] = rand()%100;
        printf("%d ", a[i]);
    }

    quickSort(a, 0, MAX-1);

    printf("\n排序后:\n");
    for (i=0; i<MAX; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

void quickSort(int *a, int left, int right)
{
    if (left < right)
    {
        int i = left;
        int j = right+1;

        while (1)
        {
            while (i+1<MAX && a[++i]<a[left]);
            while (j-1>-1 && a[--j]>a[left]);

            if (i >= j)
            {
                break;
            }
            SWAP(a[i], a[j]);
        }

        SWAP(a[left], a[j]);

        quickSort(a, left, j-1);
        quickSort(a, j+1, right);
    }
}

2. 對於上述方法進行改進，將基准值設定為序列中間的數，從中間向兩邊尋找

/*
 *2012年2月13日16:26:31
 *從中間向兩邊查找，具體過程類似於容易理解的版本
 */

#include <stdio.h>
#include <time.h>

#define MAX 10
#define SWAP(x, y) {int t=x; x=y; y=t;}

void quickSort(int *a, int left, int right);

int main(void)
{
    int a[MAX] = {0};
    int i;

    srand(time(NULL));

    printf("排序前:\n");
    for (i=0; i<MAX; i++)
    {
        a[i] = rand()%100;
        printf("%d ", a[i]);
    }

    quickSort(a, 0, MAX-1);

    printf("\n排序后:\n");
    for (i=0; i<MAX; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

void quickSort(int *a, int left, int right)
{
    if (left < right)
    {
        int t = a[(left+right)/2];
        int i = left - 1;
        int j = right + 1;

        while (1)
        {
            while (a[++i] < t);
            while (a[--j] > t);

            if (i >= j)
            {
                break;
            }
            SWAP(a[i], a[j]);

        }

        quickSort(a, left, i-1);
        quickSort(a, j+1, right);
    }
}

3. 再次改進算法。

      有指針left和right，對於right，如果其所指的元素的值大於或者等於基准值，那么指針往左移一位，如果小於基准值，則和基准值交換；同理，對於left，如果left所指元素的值小於或者等於基准值，那么指針往右移一位，如果大於基准值，則和基准值交換。從right開始執行，重復這兩步驟，直至left == right為止。

　　對於基准的選取會影響算法的性能，這里取第一個元素為pivot。

/*
 *2012年2月13日16:42:45
 *效率較高的實現
 */

#include <stdio.h>
#include <time.h>

#define MAX 10
#define SWAP(x, y) {int t=x; x=y; y=t;}

void quickSort(int *a, int left, int right);
int Partition(int *a, int left, int right);

int main(void)
{
    int a[MAX] = {0};
    int i;

    srand(time(NULL));

    printf("排序前:\n");
    for (i=0; i<MAX; i++)
    {
        a[i] = rand()%100;
        printf("%d ", a[i]);
    }

    quickSort(a, 0, MAX-1);

    printf("\n排序后:\n");
    for (i=0; i<MAX; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

int Partition(int *a, int left, int right)
{
    int pivot = a[left];
    while (left < right)
    {
        while (left < right && a[right] >= pivot)
        {
            --right;
        }
        a[left] = a[right];
        while (left < right && a[left] <= pivot)
        {
            ++left;
        }
        a[right] = a[left];
    }

    return left;
}

void quickSort(int *a, int left, int right)
{
    int pivot;

    if (left < right)
    {
        pivot = Partition(a, left, right);
        quickSort(a, left, pivot-1);
        quickSort(a, pivot+1, right);
    }

}