快速排序算法

快速排序算法的描述
算法导论，第7章
快速排序时基于分治模式处理的，
对一个典型子数组A[p...r]排序的分治过程为三个步骤：
1.分解：
A[p..r]被划分为俩个（可能空）的子数组A[p ..q-1]和A[q+1 ..r]，使得
A[p ..q-1] <= A[q] <= A[q+1 ..r]
2.解决：通过递归调用快速排序，对子数组A[p ..q-1]和A[q+1 ..r]排序。
3.合并。

 

快速排序算法

QUICKSORT(A, p, r)
1 if p < r
2    then q ← PARTITION(A, p, r)   //关键
3         QUICKSORT(A, p, q - 1)
4         QUICKSORT(A, q + 1, r)

数组划分
快速排序算法的关键是PARTITION过程，它对A[p..r]进行就地重排：
PARTITION(A, p, r)
1  x ← A[r]
2  i ← p - 1
3  for j ← p to r - 1
4       do if A[j] ≤ x
5             then i ← i + 1
6                  exchange A[i] <-> A[j]
7  exchange A[i + 1] <-> A[r]
8  return i + 1

 

ok，咱们来举一个具体而完整的例子。
来对以下数组，进行快速排序，
  2   8   7   1   3   5   6   4(主元)

一、

i p/j

  2   8   7   1   3   5   6   4(主元)
j指的2<=4，于是i++，i也指到2，2和2互换，原数组不变。
j后移，直到指向1..
二、
              j（指向1）<=4，于是i++
i指向了8，所以8与1交换。
数组变成了：
       i          j
  2   1   7   8   3   5   6   4
三、j后移，指向了3,3<=4，于是i++
i这是指向了7，于是7与3交换。
数组变成了：
             i         j
  2   1   3   8   7   5   6   4
四、j继续后移，发现没有再比4小的数，所以，执行到了最后一步，
即上述PARTITION(A, p, r)代码部分的 第7行。
因此，i后移一个单位，指向了8
                 i               j
  2   1   3   8   7   5   6   4
A[i + 1] <-> A[r]，即8与4交换，所以，数组最终变成了如下形式，
  2   1   3   4   7   5   6   8
ok，快速排序第一趟完成。

4把整个数组分成了俩部分，2 1 3,7 5 6 8，再递归对这俩部分分别快速排序。
i p/j
  2   1   3(主元)
  2与2互换，不变，然后又是1与1互换，还是不变，最后，3与3互换，不变，
最终，3把2 1 3，分成了俩部分，2 1，和3.
再对2 1，递归排序，最终结果成为了1 2 3.

7 5 6 8(主元)，7、5、6、都比8小，所以第一趟，还是7 5 6 8，
不过，此刻8把7 5 6 8，分成了  7 5 6，和8.[7 5 6->5 7 6->5 6 7]
再对7 5 6，递归排序，最终结果变成5 6 7 8。

递增和递减的排序主要看PARTITION（）函数所取元素的排序方式，递增排序，怎按数组按递增排序

代码详解：

#include <stdio.h>#include <stdlib.h>#include <malloc.h>#include <time.h>void PrintArr(int *pnArr, int nLen){    for (int i = 0; i < nLen; i++)    {        printf("%d ", pnArr[i]);    }    printf("\n");}void Swap(int *p1, int *p2){    int nTmp = *p1;    *p1 = *p2;    *p2 = nTmp;}//实现对子数组[nLeft - nRight]的原址重排，将主元素放到合适位置//递增排序int Patition1(int *pnArr, int nLeft, int nRight){    int nKey = pnArr[nRight];    int i = nLeft - 1;    for (int j = nLeft; j < nRight; j++)    {        if (pnArr[j] <= nKey)        {            i++;            Swap(&pnArr[i], &pnArr[j]);        }    }        //将主元素插入到中间位置    Swap(&pnArr[i+1], &pnArr[nRight]);    return i+1;}//递增排序   nTmpPos左边的值都小于它，右边的值都大于它int Patition2(int *pnArr, int nLeft, int nRight){    int nKey = nRight;    int i = nLeft - 1;    bool bExchange = false;    for (int j = nLeft; j < nRight; j++)    {        if (pnArr[j] < pnArr[nKey])        {            i++;            Swap(&pnArr[i], &pnArr[j]);            bExchange = true;        }    }    Swap(&pnArr[i+1],&pnArr[nRight]);    if (bExchange)    {        return i+1;    }    else    {        return (nLeft + nRight) / 2;    }}//递减排序  nTmpPos左边的值都大于它，右边的值都小于它int Patition3(int *pnArr, int nLeft, int nRight){    int nKey = nRight;    int i = nLeft - 1;    for (int j = nLeft; j < nRight; j++)    {        if (pnArr[j] > pnArr[nKey])        {            i++;            Swap(&pnArr[i],&pnArr[j]);        }    }                                               Swap(&pnArr[i+1], &pnArr[nRight]);    return i + 1;}//寻找一个nTmpPos下标，nTmpPos左边的值都小于它，右边的值都大于它void QuickSort(int *pnArr, int nLeft, int nRight){    if (nLeft < nRight)    {        //分解        int nTmpPos = Patition2(pnArr, nLeft, nRight);        //解决/合并        QuickSort(pnArr, nLeft, nTmpPos - 1);   //按二叉树，一分二，进行分解，左分支，然后再调用函数中进行排序递增或者递减        QuickSort(pnArr, nTmpPos + 1, nRight);//二叉树右分支的排序    }}int main(){    int nArr[10] = {42,1,3,2,16,9,10,14,8,17};         PrintArr(nArr, 10);    QuickSort(nArr, 0,9);    PrintArr(nArr, 10);    system("pause");    return 0;}