快速排序总结

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

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);
}
}
}

参考文档：

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