快速排序算法

快速排序算法的描述
算法导论，第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;
}