快速排序递归与非递归

快速排序思想：以升序为例；在要排序的序列中选一个基准，使它左边的数都比它小，右边的数都比它大。具体步骤：1、区间选一个key，可以选区间右边界的那个数；2、让begin从区间左边界开始往后找大于key的数，找到后停下来，再让end从区间右边界-1开始往前找小于key的数，找到后让它和begin找的大的数交换；3、begin继续找大的，end继续找小的，如果begin和end相遇了，那么比较相遇点的数和key的大小，若大于key，就让相遇点的数和key交换，返回相遇点，否则返回区间右边界。

int PartSort(int *array,int left, int right)
{
    assert(array);
    int key = array[right];
    int begin = left;
    int end = right-1;
    while (begin < end)   //section
    {
        while (begin < end && array[begin] <= key)//找到大的
        {
            ++begin;
        }
        while (begin < end && array[end] >= key)//找到小的
        {
            --end;
        }
        swap(array[begin], array[end]);
    }
    //相遇且相遇点的值大于key
    if (array[begin]>key)
    {
        swap(array[begin], array[right]);
        return begin;
    }
    //相遇但相遇点的值小于key
    else
    {
        return right;
    }
}

void SectionSort(int *array,int left, int right)
{
    assert(array);
    if (left < right)
    {
        int boundary = PartSort(array, left, right);

        SectionSort(array, left, boundary - 1);
        SectionSort(array, boundary + 1, right);
    }
}

void QuickSort(int *array, size_t size)
{
    assert(array);
    int left = 0;
    int right = size - 1;
    SectionSort(array, left, right);
}

优化：三数取中，保证每次的key值不是最大的或最小的

int GetMiddleIndex(int *array,int left, int right)
{ 
    assert(array);
    int mid = left + (right - left) / 2;
    int min = array[left] > array[right] ? right : left;
    if (array[min] > array[mid])
    {
        return min;
    }
    else
    {
        int second = right + left - min;
        if (array[second] > array[mid])
        {
            return mid;
        }
        else
        {
            return second;
        }
    }
}
int PartSort(int *array, int left, int right)
{
    assert(array);
    int key = array[right];
    int begin = left;
    int end = right-1;
    while (begin < end)   //section
    {
        while (begin < end && array[begin] <= key)//找到大的
        {
            ++begin;
        }
        while (begin < end && array[end] >= key)//找到小的
        {
            --end;
        }
        swap(array[begin], array[end]);
    }
    //相遇且相遇点的值大于key
    if (array[begin]>key)
    {
        swap(array[begin], array[right]);
        return begin;
    }
    //相遇但相遇点的值小于key
    else
    {
        return right;
    }
}
 void SectionSort(int *array, int left, int right)
{
    assert(array);
    if (left < right)
    {
        if (right - left < 10)
        {
            int boundary = PartSort(array, left, right);

            SectionSort(array, left, boundary - 1);
            SectionSort(array, boundary + 1, right);
        }
        else
        {
            InsertSort(array + left, right - left + 1);
        }
    }
}

void QuickSort(int *array, size_t size)
{
    assert(array);
    int left = 0;
    int right = size - 1;
    SectionSort(array, left, right);
}

快速排序非递归：
用栈来保存区间，划分区间相当于一棵二叉树，第一次整个区间排序，那么把整个区间看做二叉树的根节点，key值会划分出左右区间，相当于左右子树，将左右区间压栈，循环取栈顶区间排序，并把新分出来的区间压栈，直到栈为空，循环结束，全部区间都已排好序。整个过程可以看做二叉树的深度遍历。

int PartSort(int *array, int left, int right)
{
    assert(array);
    int key = array[right];
    int begin = left;
    int end = right-1;
    while (begin < end)
    {
        while (begin < end && array[begin] <= key)
        {
            ++begin;
        }
        while (begin < end && array[end] >= key)
        {
            --end;
        }
        swap(array[begin], array[end]);
    }
    if (array[begin]>key)
    {
        swap(array[begin], array[right]);
        return left;
    }
    return right;
}

//每次的区间范围压栈，取栈顶区间PartSort，并继续划分区间压栈，相当于深度扩展树节点
void QuickSort2(int *array, size_t size)
{
    assert(array);
    int left = 0;
    int right = size-1;
    stack<int> s;

    if (left < right)
    {
        int mid = PartSort(array, left, right);
        //key值切分的区间压栈
        if (left < mid - 1)
        {
            s.push(left);
            s.push(mid-1);
        }
        if (right>mid + 1)
        {
            s.push(mid + 1);
            s.push(right);
        }
    }
    while (!s.empty())
    {
        right = s.top();
        s.pop();
        left = s.top();
        s.pop();
        int mid = PartSort(array, left, right);
        if (left < mid-1)
        {
            s.push(left);
            s.push(mid - 1);
        }
        if (right>mid + 1)
        {
            s.push(mid + 1);
            s.push(right);
        }
    }
}