快速排序非递归实现

再来谈谈快速排序，递归实现与非递归实现。
递归实现是基本的排序；非递归实现需要用stack来存储 (low, high)的排序对，一部分一部分的排序。
直接上程序了：
头文件 quick_test.h

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

/
#include <stack>
#include <iostream>
typedef struct REGION{
    long low;
    long high;
} Region;
///

//#define N 100000000
#define N 15
//#define M 1000000000
#define M 1000

typedef long Data;

void SwpData(Data &data1, Data &data2);

void quickSort(Data *arr, long low, long high);

long partition(Data *arr, long low, long high);

void quickSortNew(Data *arr, long low, long high);

简单的排序主函数，quick_test.cpp

#include "quick_test.h"

void SwpData(Data &data1, Data &data2)
{
    Data tmp = data1;
    data1 = data2;
    data2 = tmp;
}

void quickSort(Data *arr, long low, long high)
{
    if(low >= high)
        return;
    long ind = 0;
    ind = partition(arr, low, high);
    if(ind != -1 && ind - 1 > low)
        quickSort(arr, low, ind - 1);
    if(ind != -1 && ind + 1 < high)
        quickSort(arr, ind + 1, high);

}

long partition(Data *arr, long low, long high)
{
    if(low >= high)
        return -1;
    long len = high - low + 1;
    srand( (unsigned)time(NULL) );
    long ind = rand() % len + low;
    if(ind != high)
        SwpData(arr[ind], arr[high]);
    Data num = arr[high];
    long i = low, j = high;
    while(i < j)
    {
        while(i < j && num > arr[i])
            ++ i;
        arr[j] = arr[i];
        while(i < j && arr[j] >= num)
            -- j;
        arr[i] = arr[j];
    }
    arr[i] = num;
    return i;
}

void quickSortNew(Data *arr, long low, long high)
{
    std::stack<Region> rstac;
    Region region;
    region.low = low;
    region.high = high;
    rstac.push(region);
    long ind = low;
    long i = 0, j = 0;
    while(!rstac.empty())
    {
        Region tmp = rstac.top();
        rstac.pop();
        i = tmp.low;
        j = tmp.high;
        ind = partition(arr, i, j);
        if(ind - 1 > i && ind != -1)
        {
            tmp.low = i;
            tmp.high = ind - 1;
            rstac.push(tmp);
        }
        if(ind + 1 < j && ind != -1)
        {
            tmp.low = ind + 1;
            tmp.high = j;
            rstac.push(tmp);
        }
    }
}

int main(int argc, char *argv[])
{
    if(argc < 2)
    {
        printf("Usage : %s randnum.txt\n", argv[0]);
        exit(-1);
    }
    srand( (unsigned)time(NULL) );
    Data num = 0;
    Data *arr = new Data[N];  //attention 
    long i = 0;
    FILE *fp;
    fp = fopen(argv[1], "wb");
    if(NULL == fp)
    {
        printf("Open file wrong!\n");
        exit(-1);
    }
    for(i = 0; i < N; ++ i)
    {
        num = rand();
        arr[i] = num % M;
        fprintf(fp, "%ld\n", arr[i]);
    }
    fclose(fp);

    ///////////////////////////////////////////////
    //quickSort(arr, 0, N - 1);

    quickSortNew(arr, 0, N - 1);
    ///////////////////////////////////////////////

    char line[10240];
    snprintf(line, 10240, "%s.sort", argv[1]);
    fp = fopen(line, "wb");
    if(NULL == fp)
    {
        printf("Open file wrong!\n");
        exit(-1);
    }
    for(i = 0; i < N; ++ i)
        fprintf(fp, "%ld\n", arr[i]);
    delete [] arr; //attention
    return 0;
}

变量的空间分配——栈与堆

这里值得一提的是，堆与栈空间的分配问题，定义的变量在栈空间，栈空间对数据的大小有很大的限制，最大到十万级，当直接分配百万级的空间，程序在运行时会出core，然而用堆就可以实现百万千万的空间分配。
堆空间分配变量，new与delete，现在明白堆空间的方便与灵活之处了，也就是代码中标示 attention之处