本文简要介绍快排序的非递归实现方式并给出了C语言版本的源代码，非递归实现由于没有函数调用的消耗，相对于递归方式有一定的优势。
在快排序的递归实现中，函数quicksort(int nlow, int nhigh)递归的时候两个参和high在改变。

非递归实现中可以用两个栈int low[MAX_SIZE] , int high[MAX_SIZE]来模拟系统栈对nlow和nhigh的

存储情况。非递归快排的具体实现比较简单，需要说明的是，MAX_SIZE这里等于32就可以了，因为

快速排序的空间复杂度是O(log2N)，而整数最大时2^32，因此两个模拟栈的大小是32就可以了。

非递归快排序的源码如下：

/*
 * Author: puresky
 * Date: 2010/01/08
 * Purpose: Nonrecursive quicksort
 */

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

//Nonrecursive quicksort
void quicksort2(int a[], int n)
{
#define STACK_MAX 32 //the space complexity of quicksort is O(logN), so 32 is enough!
#define SWAP(a, b) {int temp = a; a = b; b = temp;}

        int low[STACK_MAX]; //low position stack
        int high[STACK_MAX]; // high position stack
        int top = -1; //stack top

        top++;
        low[top] = 0;
        high[top] = n - 1;

        while(top >= 0) // stack is not empty
        {
                int L = low[top];
                int R = high[top];
                top--;

                //printf("TOP:%d,L:%d,R:%d\n", top, L, R);

                if( L < R)
                {
                        //partion
                        SWAP(a[L], a[L + rand() % ( R - L + 1)]);
                       
                        int i;
                        int m = L;
                        for(i = L + 1; i <= R; ++i)
                        {       
                                if(a[i] < a[L])
                                {
                                        ++m;
                                        SWAP(a[m], a[i]);
                                }
                        }
                        SWAP(a[m], a[L]);
                       
                       //left part entering stack
                        if(L < m - 1)
                        {
                                top++;
                                low[top] = L;
                                high[top] = m - 1;
                        }
 
                        //rigth part entering stack
                        if(m + 1 < R)
                        {
                                top++;
                                low[top] = m + 1;
                                high[top] = R;
                        }
                }
        }
}

void print(int a[], int n)
{
        int i;
        for(i = 0; i < n; ++i)
                printf("%d ", a[i]);
        printf("\n");
}

int* init_array(int n)
{
        int i;
        int *a = (int*)malloc(sizeof(int) * n);
        for(i = 0; i < n; ++i)
                a[i] = rand() % n;
        return a;
}

void free_array(int *a)
{
        free(a);
}

int main(int argc, char** argv)
{
        srand(time(NULL));
        const int n = 100;
        int *a = init_array(n);
        quicksort2(a, n);
        print(a, n);
        free_array(a);
        system("pause");
        return 0;
}