排序算法大杂烩之快速排序

排序算法大杂烩主干文章传送门

快速排序

• 接着主文章结构继续分析快速排序
• 快速排序实现主流上分为两种，第一种为快排的开山鼻祖$C.A.R.Hoare$在1962年给出的，第二种是后来者给出的另一种实现方案。本文给出两种并非最原始的，而是经过随机化主元后给出的改进方案。

#include 
#include 
#include 
#include 

using namespace std;

void swap(int &a,int &b){int c = a;a = b;b = c;}

int partition(vector<int> &a,int low,int high)
{
    //C. A. R. Hoare
    srand(unsigned(time(NULL)));
    int j = low + rand()%(high - low + 1);
    swap(a[high],a[j]);
    j = low;
    for(int i = low;i < high;i ++){
        if(a[i] <= a[high])swap(a[i],a[j++]);
    }
    swap(a[j ],a[high]);
    return j ;
}

int partition2(vector<int>&a,int low,int high)
{
    srand(unsigned(time(NULL)));
    int j = low + rand()%(high - low + 1);
    swap(a[high],a[j]);
    int pivot = a[high];
    while(low < high){
        while(low < high && a[low] <= pivot){low ++;}
        a[high] = a[low];
        while(low < high && a[high] > pivot){high --;}
        a[low] = a[high];
    }
    cout << low << " " << high << ";\n";
    a[low] = pivot;
    return low;
}

void quickSort(vector<int> &a,int low,int high)
{
    if(low >= high) return ;
    int pivot = partition(a,low,high);
    quickSort(a,low,pivot-1);
    quickSort(a,pivot+1,high);
}

int main()
{
    vector<int> a = {1,40,10,4,5,8,9,1};
//    cout << partition2(a,0,a.size()-1) << "|";
    quickSort(a,0,a.size()-1);
    for(auto c : a) cout << c << " ";
    return 0;
}

• 思路引擎

• 快速排序是利用分治策略完成，分成三部曲：分解，解决，合并。
  问题定义：将序列$A[1..n]$非降序
  分解：将序列$A[l..h]$找到r,并使得$A[l..r-1]$的元素均小于$A[r]$，$A[r+1..h]$均大于$A[r]$
  解决：递归的调用快速排序算法，对$A[l..r-1]$，$A[r+1..h]$在进行排序
  合并：所有子数组已经有序，无需进行合并操作。

• 如何分解子数组，使得满足分治的目的
  方法一：

  1. 空出首元素（首元素作为主元），$h$ 端 $l$ 端向序列中间进行扫描；
  2. 对于 $h$ 端元素，如果该元素小于$A[r]$填补 $l$ 端空缺位，那么该元素所占据的位置就成了空缺位，然后切换到 $l$ 端；
  3. 对于 $l$ 端元素，如果该元素大于$A[r]$填补 $l$ 端空缺位，那么该元素所占据的位置就成了空缺位，然后切换到 $h$ 端；
  4. 若 $l$ 端与 $l$ 端相遇，那么相遇点一定是空缺位，再用主元元素填补就可以了。

  方法二：

  1. 设置两个变量i、j，排序开始的时候：i=0，j=N-1；
  2. 以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
  3. 从j开始向前搜索，即由后开始向前搜索(j- -)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；3. 从j开始向前搜索，即由后开始向前搜索(j- -)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
  4. 从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
  5. 重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

  方法二的描述引用自 百度百科-快速排序

• 时间复杂度

  1. 快速排序的时间复杂度与数组划分的效果有关，下面给出两个极端下的时间复杂度求解

     • 当每次数组划分都只纯粹划分成长度为1和长度为$h-l$的两个部分，时间复杂度
       $$\begin{gathered} T(n)=T(n-1)+o(n) \\ \Rightarrow T(n)=o(n^2) \end{gathered}$$
     • 当每次数组划分是都能划分成两个相等的部分，则时间复杂度可表示
       $$\begin{gathered} T(n)=2T(n/2)+o(n) \\ \Rightarrow T(n)=o(nlogn) \end{gathered}$$
       这里由递归式求时间复杂度采用的主方法，感兴趣的可移步。

  2. 由于上面的分析可以看出数据的分布对快排的影响很大，为了尽量减少这方面的影响，我们在选取主元的时候尽量随机选择，而不是机械的选择最首或者最尾。这样快排的期望时间复杂度就变成了$o(nlgn)$，具体的证明可以参考算法导论的相关内容。

• 稳定性分析
  这边很容易可以看出快排是不稳定，原因和选择排序比较类似，我们在进行置换元素时，无法判定置换后的位置前方是否存在键值相同元素，换句话说在置换时无法确保相同键值元素的相对次序。