快速排序——C语言实现

递归实现：

void quickSort(int a[], int size)
{
    int i = 0, j = size-1;
    int val;

    if(size < 2)
        return;

    val = a[0];
    while(i < j){
        for(;j>i;j--){
            if(a[j] < val){
                a[i++] = a[j];
                break;
            }
        }

        for(;i<j;i++){
            if(a[i]>val){
                a[j--] = a[i];
                break;
            }
        }   
    }

    a[i] = val;
    quickSort(a, i);
    quickSort(a+i+1, size-i-1);
}

非递归：

#define STKSIZ 32

static void swap(int *a, int *b)
{
    int tmp;
    if(*a != *b){
        tmp = *a;
        *a = *b;
        *b = tmp;
    }
}

void quickSort(int a[], int num)
{
    int *lo, *hi, *mid;
    int *loguy, *higuy;
    int size;
    int *lostk[STKSIZ], *histk[STKSIZ];
    int stkptr = 0;

    if(num < 2)
        return;

    lo = a;
    hi = a + num - 1;

recurse:

    size = hi - lo + 1;
    mid = lo + size / 2;

    if(*lo > *mid)
        swap(lo, mid);

    if(*lo > *hi)
        swap(lo, hi);

    if(*mid > *hi)
        swap(mid, hi);

    loguy = lo;
    higuy = hi;

    for(;;){
        if(mid > loguy){
            do {
                loguy++;
            }while(loguy < mid && *loguy <= *mid);
        }

        if(mid <= loguy){
            do{
                loguy++;
            }while(loguy <= hi && *loguy <= *mid);
        }

        do {
            higuy--;
        }while(higuy > mid && *higuy > *mid);

        if(loguy > higuy)
            break;

        swap(loguy, higuy);

        if(mid == higuy)
            mid = loguy;
    }

    higuy++;
    if(mid < higuy){
        do{
            higuy--;
        }while(higuy > mid && *higuy == *mid);
    }

    if(mid >= higuy){
        do {
            higuy--;
        }while(higuy > lo && *higuy == *mid);
    }

    if(higuy - lo >= hi - loguy){
        if(lo < higuy){
            lostk[stkptr] = lo;
            histk[stkptr] = higuy;
            ++stkptr;
        }

        if(loguy < hi){
            lo = loguy;
            goto recurse;
        }
    }
    else{
        if(loguy < hi){
            lostk[stkptr] = loguy;
            histk[stkptr] = hi;
            ++stkptr;
        }

        if(lo < higuy){
            hi = higuy;
            goto recurse;
        }
    }

    --stkptr;
    if(stkptr >= 0){
        lo = lostk[stkptr];
        hi = histk[stkptr];
        goto recurse;
    }
    else
        return;
}