快速排序总结

    快速排序是相当重要的一种排序方法。它的特点有：

1. 平均时间复杂度为O(nlogn)，最坏时间复杂度为O(n^2)。

2. 平均空间复杂度为O(logn)，最坏空间复杂度为O(n)。

3. 不稳定

    快排的实现方法有多种，这里只列出常用的两种。

单向扫描版：

int partition(int arr[], int p, int r)
{
    int x = arr[r];
    int i = p - 1;
    for (int j = p; j < r; ++j)
    {
        if (arr[j] <= x)
        {
            ++i;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i+1], arr[r]);
    return i + 1;
}

双向扫描版：

int partition(int *a,int p,int r)
{
    int i = p,j = r;
    int x = a[p];
    while (i < j)
    {
        while (i < j && a[j] >= x)
            j--;
        if (i < j)
            a[i++] = a[j];
        while (i < j && a[i] <= x)
            i++;
        if (i < j)
            a[j--] = a[i];
    }
    a[i] = x;
    return i;
}

主调用：

void QuickSort(int *a,int p,int r)
{
    if (p<r)
    {
        int q = partition(a,p,r);
        QuickSort(a,p,q-1);
        QuickSort(a,q+1,r);
    }
}

    递归是实现快排的主要策略。当然也可以非递归实现快排。

快排非递归版：

void quicksortIterative(int arr[], int s, int e)
{
    stack<int> stk;
    stk.push(s);
    stk.push(e);
    while (!stk.empty())
    {
        int end = stk.top();
        stk.pop();
        int start = stk.top();
        stk.pop();
        int mid = partition(arr, start, end);
        if (start < mid - 1)
        {
            stk.push(start);
            stk.push(mid - 1);
        }
        if (mid + 1 < end)
        {
            stk.push(mid + 1);
            stk.push(end);
        }
    }
}

参考文档：

快速排序-递归和非递归的实现