快速排序及其优化

我们今天来研究下快速排序，快速排序的一个整体的思想就是分治的思想，在这个过程当中，首先对一个大区间进行单趟快速排序，然后把大区间分成多个区间，再去进行单趟排序，一直到这个区间中的元素只剩下一个元素，这样重复以后就可以得到最后的排序后的结果。

1.单趟排序分析

---

快速排序的最重要的就是单趟排序，接下来就是进行分治的单趟排序，所以我们来重点说一下单趟排序。

我们在这里介绍关于快速排序的单趟排序的三种方法。

左右指针法： 这种方法我们首先需要选择一个key，然后给定一个left和一个right，维护left和right这段区间，在此期间，left要++，right要–，然后left找到比key大的一个数，right找到比key小的一个数，把他们进行交换，一直到left==right，这个时候级就可以把key放到位置上了。这就是最简单选key的方法的单趟排序，进行完单趟排序后，这个时候只把key值放到了该出现的位置，然后进行分割区间，转换为子问题递归。

//左右指针法
template<typename T>
int portsort(T* arr, int begin, int end)
{
    assert(arr);
    int left = begin;
    int right = end;
    //利用三位取中优化效率，避免key是最小或者最大值的情况。
    int mid = SelectMid(arr, begin, end);
    std::swap(arr[mid], arr[end]);

    T key = arr[end];
    while (left<right)
    {
        while (left<right&&arr[left] <= key)
        {
            left++;
        }

        while (left<right&&arr[right] >= key)
        {
            right--;
        }
        //左边比key大的和右边比key小的进行交换
        if (arr[left]>arr[right])
        {
            swap(arr[left], arr[right]);
        }
    }
    //修正放入key
    swap(arr[left], arr[end]);

    return left;
}

挖坑法：首先找一个最左或者是最右端作为一个起始坑，保存坑中的值，然后如果在最左，那么就让left找一个比保存值大的，然后进行把这个值填坑，填完以后现在这个值的这个位置就变成了坑，然后我们继续让right在区间内找一个比保存值小的，找到以后填了刚才的坑，现在这个位置变成了新坑，这样一直继续下去，直到left==right，这个时候坑无法再次变动，把保存的初始值填入坑中。这个就是挖坑法的单趟排序。

//挖坑法
template<typename T>
int PortSort2(T* arr, int begin, int end)
{
    assert(arr);
    int left = begin;
    int right = end;
    int mid = SelectMid(arr, begin, end);
    std::swap(arr[mid], arr[end]);
    //最后一个作为坑
    T hole = arr[end];
    while (left<right)
    {
        while (left<right&&arr[left] <= hole)
        {
            left++;
        }
        //填坑
        if (left < right)
            arr[right--] = arr[left];
        while (left < right&&arr[right] >= hole)
        {
            right--;
        }
        //填坑
        if (left < right)
            arr[left++] = arr[right];
    }
    //最后位置为坑初始元素
    arr[left] = hole;
    return left;
}

前后指针法：，一个cur，一个prev，这个时候prev初始化为begin-1，
然后我们就是cur找一个比key小的，找到以后prev++，然后把arr[prev]和arr[end]进行交换
其实达到的效果就是把小的放到前面，放到前面。最后把key放到prev+1的位置就好了。

//第三种方法：前后指针方法，一个cur，一个prev，这个时候prev初始化为begin-1，
//然后我们就是cur找一个比key小的，找到以后prev++，然后把arr[prev]和arr[end]进行交换
//其实达到的效果就是把小的放到前面，放到前面。最后把key放到prev+1的位置就好了。

template<typename T>
int PortSort3(T* arr, int begin, int end)
{
    assert(arr);
    int prev = begin-1;
    int cur = begin;
    int pos = SelectMid(arr, begin, end);
    std::swap(arr[pos], arr[end]);
    T key = arr[end];
    while (cur < end)
    {
        if (arr[cur]<key&&++prev != cur)
        {
            std::swap(arr[cur], arr[prev]);
        }
        cur++;
    }
    std::swap(arr[++prev], arr[end]);
    return prev;
}

2.递归快排实现

---

递归的实现很简单就是首先对整个区间进快排，然后分成两个小区间快排，最后再转化成递归问题进行快排。

template<typename T>
void QuickSort(T* arr, int begin, int end)
{
    assert(arr);
    if (begin<end)
    {
        //进行第一次单趟排序
        int div = PortSort(arr, begin, end);
        //递归子问题，划分区间
        QuickSort(arr, begin, div - 1);
        //递归子问题
        QuickSort(arr, div + 1, end);
    }

}

3.非递归快排的实现

---

非递归的方式实现快速排序：
我们首先认识到，对于递归的问题转换成非递归，我们可以利用栈的数据特性来实现，在栈中保留下来递归的条件，这样就可以达到我们想要的效果了。
这里的条件就是我们来简单的控制begin和end就可以实现。

//非递归的快速排序
//非递归的解决方式就是利用栈进行解决
template<typename T>
void QuickSort4(T* arr, int begin, int end)
{
    assert(arr);
    std::stack<int> q;
    q.push(begin);
    q.push(end);
    while (!q.empty())
    {
        int right = q.top();
        q.pop();
        int left = q.top();
        q.pop();
        if (right > left)
        {
            int div = PortSort2(arr, left, right);

            q.push(left);
            q.push(div - 1);

            q.push(div + 1);
            q.push(right);
        }
    }
}

4.快速排序的优化思路

---

对于快速排序有的优化思路：
三数取中法:为了防止出现我们所选取的可以是最大的或者最小的，造成一个快速排序的效率接近了冒泡排序的效率。为了更加高效，就需要使用三数取中的方法。

//快排的优化的方法：三位取中
//取得一个中位数，对于快排来说，可以使得时间复杂度更加接近logN
template<typename T>
int SelectMid(T* arr, int begin, int end)
{
    int left = begin;
    int right = end;

    //(begin+end)>>1;
    int mid = begin + ((end - begin) >> 1);

    if (arr[left]<arr[mid])
    {
        if (arr[right]>arr[mid])
            return mid;
        if (arr[left] < arr[right])
            return right;
        else
            return left;
    }
    else
    {
        if (arr[right] < arr[mid])
            return mid;
        if (arr[right]>arr[left])
            return left;
        else
            return right;
    }
}

可以优化递归的层数，对一些接近有序的情况使用插入排序。可以优化时间复杂度接近N。
所以我们可以修改代码：

template<typename T>
void QuickSort1(T* arr, int begin, int end)
{
    assert(arr);
    if (end-begin > 13)
    {
        int div = portsort(arr, begin, end);
        QuickSort1(arr, begin, div - 1);
        QuickSort1(arr, div + 1, end);
    }
    else
    {
        InsertSort(arr+begin, (end - begin + 1) );
    }

}

注：插入排序的实现详见我前面的博客。

5.总结

---

快速排序在优化以后效率可以达到O（logN）。在同为O(N*logN)的几种排序方法中效率较高