快速排序C语言实现

非递归实现：

#include <stdio.h>

#define MAX_THRESH 4

typedef struct{
    int *lo;
    int *hi;
}stack_node;

#define STACK_SIZE (8 * sizeof(int))
#define PUSH(low, high) ((void) ((top->lo = (low)), (top->hi = (high)), ++top))
#define POP(low, high) ((void) (--top, (low = top->lo), (high = top->hi)))
#define STACK_NOT_EMPTY (stack < top)

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

void quick_sort(int a[], int n)
{
    if (n > MAX_THRESH){
        int *lo = a;
        int *hi = a + n - 1;
        stack_node stack[STACK_SIZE];
        stack_node *top = stack;

        PUSH(NULL, NULL);

        while(STACK_NOT_EMPTY){
            int *left_ptr;
            int *right_ptr;
            
            int *mid = lo + (hi - lo) / 2;

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

            left_ptr = lo + 1;
            right_ptr = hi - 1;

            do{
                while(*left_ptr < *mid) left_ptr++;
                while(*right_ptr > *mid) right_ptr--;

                if (left_ptr < right_ptr){
                    swap(left_ptr, right_ptr);
                    if (mid == left_ptr)
                        mid = right_ptr;
                    else if (mid == right_ptr)
                        mid = left_ptr;
                    left_ptr++;
                    right_ptr--;
                }
                else if (left_ptr == right_ptr){
                    left_ptr++;
                    right_ptr--;
                    break;
                }
            }while(left_ptr <= right_ptr);

            if (right_ptr - lo <= MAX_THRESH){
                if (hi - left_ptr <= MAX_THRESH)
                    POP(lo, hi);
                else
                    lo = left_ptr;
            }
            else if (hi - left_ptr <= MAX_THRESH)
                hi = right_ptr;
            else if ((right_ptr - lo) > (hi - left_ptr)){
                PUSH(lo, right_ptr);
                lo = left_ptr;
            }
            else{
                PUSH(left_ptr, hi);
                hi = right_ptr;
            }
        }
    }

#define MIN(x, y) ((x) < (y) ? (x) : (y))
    {
            int i, j, min;
            
            min = 0;
            for(i = 1; i < MIN(n, MAX_THRESH); i++)
                if (a[i] < a[min])
                    min = i;
            if (min != 0)
                swap(a, a+min);

            for(i = 1; i < n - 1; i++){
                int tmp = a[i+1];
                for(j = i; j>=0; j--)
                    if(a[j] > tmp)
                        a[j+1] = a[j];
                    else
                        break;
                
                a[j+1] = tmp;
            }
    }
}

int main()
{
    int a[] = {1,1,5,6};
    quick_sort(a, 4);
    int i;
    for(i=0;i<4;i++)
        printf("%d ", a[i]);
    
    puts("");
}