数据结构-快速排序的三种实现方式及其优化

快速排序初步了解：

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。后面将提供一种快排的优化方式可以尽量避免出现Ο(n2)的复杂度。

基本思路

1.先从数据当中找出一个数据作为参照数

2.然后开始分区操作，大于参照数的就放到参照数右边，小于参照数的就放到参照数的左边.

3.然后对左右分区继续进行该操作，知道区间里面只有一个数据的是时候，快排完成

---

排序效果：

---

一、左右指针法

<1>思路：给定一个数组，再给定左右区间的下标值left，right（此处我给的是左右闭区间），给定一个基准值为arr[right]，接下来就是循环和递归的过程。单趟过程中，先让begin记录该区间的第一个下标（就像一个指针指向头一样），end记录最后一个值的下标，基准值为该区间的最后一个值。循环过程中，begin记录比基准值大的值，end记录比基准值小的值，判断如果begin和end还未相遇，则交换对应的值，再进行循环直至begin和end相遇。相遇后此时单趟排序完成，现在begin和end指向一个元素，该元素左侧都是比基准值小的值，右侧都是比基准值大的，将begin对应的值与基准值进行交换，开始递归左半区间和右半区间，重复上述过程。

---

<2>图示单趟过程：

整体过程如下：

1 5 6 2 7 4

1 2 6 5 7 4

1 2 4 5 7 6

1 2 4 5 6 7

---

<3>实现代码

//左右指针法void LRPoint(int* arr, int left, int right){    if (left >= right)        return;    assert(arr);    int begin = left;    int end = right;    int key = arr[end];    while (begin < end)    {        while (begin < end && arr[begin] <= key)            begin++;        while (begin < end && arr[end] >= key)            end--;        if (begin < end)            swap(arr[begin], arr[end]);    }    //begin end指向一起，与key交换    swap(arr[begin], arr[right]);    LRPoint(arr, left,begin - 1);    LRPoint(arr, begin+1,right);}

---

二、挖坑法

<1>思路：大体上如同左右指针法，但是左右指针法是在begin和end符合条件的值后，将begin和end对应的值进行交换；而挖坑法则是边找边替换，在最后再将key填入坑中。图中橙色元素由于此处的值赋值到了别处，可以形象的看做是一个“坑”。

---

<2>图示单趟过程：

整体过程如下：

1 5 6 2 7 4

1 5 6 2 7 5

1 2 6 2 7 5

1 2 6 6 7 5

1 2 4 6 7 5

1 2 4 6 7 6

1 2 4 5 7 6

1 2 4 5 7 7

1 2 4 5 6 7

---

<3>实现代码

void PitPoint(int* arr, int left, int right){    if (left >= right)        return;    int begin = left;    int end = right;    int key = arr[right];    while (begin < end)    {        while (begin < end && arr[begin] <= key)            begin++;        arr[end] = arr[begin];        while (begin < end && arr[end] >= key)            end--;        arr[begin] = arr[end];    }    arr[end] = key;    PitPoint(arr, left, begin - 1);    PitPoint(arr, begin + 1, right);}

---

三、前后指针法

<1>思路：一开始使用cur记录left位置，prev记录cur的前一个位置，利用cur来寻找比基准值小的值，需要注意的是只有当arr[cur] < arr[right]和++prev != cur两个条件都满足才进行交换，此处还涉及如果arr[cur] < arr[right]不满足则不进行prev++，当条件都满足时进行交换，出了循环后将基准值放在prev++的位置。看着代码自己缕一遍就会发现规律了。

---

<2>图示单趟过程：

整体过程如下：

1 5 6 2 7 4

1 2 6 5 7 4

1 2 4 5 7 6

1 2 4 5 6 7

---

<3>实现代码

void FBPoint(int* arr, int left, int right){    if (left >= right)        return;    int cur = left;    int prev = left - 1;    while (cur < right)    {        if (arr[cur] < arr[right] && ++prev != cur)            swap(arr[cur], arr[prev]);        ++cur;    }    swap(arr[++prev], arr[right]);    FBPoint(arr, left, prev - 1);    FBPoint(arr, prev + 1, right);}

四、非递归实现

<1>思路：

用栈来模拟实现递归操作，每次从栈中取出对应的左右边界进行操作；在push边界的顺序与取栈顶数据作为左右边界的顺序要对应。

---

<2>实现代码：

void NRQuickSort(int* arr, int sz){    assert(arr);    stack<int> s;    int left = 0;    int right = sz;    s.push(right);    s.push(left);    while (!s.empty())    {        left = s.top();        s.pop();        right = s.top();        s.pop();        if (left < right)        {            int begin = left;            int end = right;            int key = arr[right];            while (begin < end)            {                //1,5,6,2,7,4                while (begin < end && arr[begin] <= key)                    begin++;                while (begin < end && arr[end] >= key)                    end--;                if (begin < end)                    swap(arr[begin], arr[end]);            }            swap(arr[begin], arr[right]);            s.push(right);            s.push(begin + 1);            s.push(begin - 1);            s.push(left);        }    }}

---

五、优化

<1>通过三数取中法选取key的下标：

当按照上面的代码如果每次取key的时候取到了待排序列中最大的或者最小的. 也就是序列有序的时候，快速排序的时间复杂度为O(N^2)，我们可以通过选择合适的key值来进行优化：也就是所谓的三数取中法（给定左右区间的下标，计算出中间下标，并返回这三个值中不大不小的那个），将该下标所对应的值和区间最右侧的值进行交换即可。拿左右指针法优化举例：

int GetMid(int* a, int left, int right){    int mid = left + ((right - left) >> 1);    // left mid    if (a[left] < a[mid])    {        if (a[right] < a[left])            return left;        else if (a[right] > a[mid])            return mid;        else            return right;    }    else    {        //mid  left        if (a[right] < a[mid])            return mid;        else if (a[right] < a[left])            return left;        else            return right;    }}void LRPoint(int* arr, int left, int right){    if (left >= right)        return;    assert(arr);    int begin = left;    int end = right;    swap(arr[end], arr[GetMid(arr, left, right)]);    int key = arr[end];    while (begin < end)    {        while (begin < end && arr[begin] <= key)            begin++;        while (begin < end && arr[end] >= key)            end--;        if (begin < end)            swap(arr[begin], arr[end]);    }    //begin end指向一起，与key交换    swap(arr[begin], arr[right]);    LRPoint(arr, left,begin - 1);    LRPoint(arr, begin+1,right);}

---

<2>小区间优化：

思路：由于递归需要建立栈帧消耗十分大，我们可以判断如果该区间内的元素值小于n（可以取5~15，视情况而定）的时候直接采取插入排序来处理该区间内的数据，就不必再多建立那么多栈帧，从而提高效率。具体实现就不给出了，只需要添加一个判断条件再引入插入排序即可。