算法导论-------快速排序QuickSort

来源：互联网发布：天云大数据编辑：程序博客网时间：2024/05/21 06:48

一、快速排序思想介绍
二、实现的三步骤（分解、子问题求解、合并）
三、C代码实现
- 3.1 快速排序双向扫描法（一）
- 3.2 partition函数双向扫描法（二）
- 3.3 partition函数双向扫描法（二）
- 3.4 partition函数单向扫描法
四、时间空间复杂度分析
五、动画演示

一、快速排序思想介绍

快速排序（QuickSort）是对冒泡排序（BubbleSort）的一种改进。排序效率在同为O(N*logN)的几种排序方法中效率较高，再加上快速排序算法是分治策略(Divide-and-ConquerMethod)的典型应用。因此很多软件公司的笔试面试，还有大大小的程序方面的考试中也常常出现快速排序的身影。博主就在蓝桥杯竞赛上遇到过。

快速排序由图灵奖得主C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的三个序列：第一个序列中所有的元素均不大于基准元素、第二个序列是基准元素、第三个序列中所有的元素均不小于基准元素。由于第二个序列已经处于正确位置，因此需要再按此方法对第一个和第三个序列分别进行排序，整个排序过程可以递归进行，最终可以使得整个序列变成有序序列。

二、实现的三步骤（分解、子问题求解、合并）

快速排序算法的基本思想是基于分治策略的，利用分治可将快速排序的基本思想描述如下：设当前待排序的序列为R[ low : high ] ，其中low <= high，如果序列的规模足够小则直接进行排序，否则分三步处理：
1、分解
在R[ low :high ]中选定一个元素作为基准元素（pivot），该基准元素的最终的位置（pivotpos）在划分的过程中确定。将比R[ pivotpos]大的数全放到它的右边R[pivotpos+1 : high]，小于或等于它的数全放到它的左边R[low : pivotpos-1 ]。

注意：基准元素如何选定，选哪个元素？基准元素最终的排序位置，在划分的过程中确定，如何确定？不要着急，下面讲解。

2、求解子问题
对两个子序列R[low :pivotpos-1 ]和R[pivotpos+1 : high]分别通过递归调用快速排序。

3、合并
由于对子序列R[low :pivotpos-1 ]和R[pivotpos+1 : high]的排序是就地进行的，所以在子序列R[low : pivotpos-1 ]和R[pivotpos+1 : high]都排序结束后，合并步骤无须做什么，整个序列R[ low : high ]就排好序了。

基准元素（pivot）的选取。

快速排序要选定基准元素，选取基准元素应该遵循平衡子问题的原则：即使得划分后的两个子序列的长度尽量相同。基准元素的选择方法有很多种，常见的方式是把待排序列的首元素作为基准元素。本篇对以首元素为基准元素的方法给出详解；以尾元素为基准元素的单向扫描法仅给出代码。

基准元素最终位置（pivotpos）的确定【一般书上都把该功能定义在partition函数中】
快速排序中基准元素对序列进行划分，从而实现分治。假定待排序列为R[ low : high ]，该划分过程以第一个元素为基准元素。

设定两个参数i和j，他们的初值分别为待排序列的下界和上界，即i=low，j=high。

选取待排序列的第一个元素R[low]为基准元素，并将该值赋值给变量pivot。

令j自j位置开始向左扫面，如果j位置所对应的元素的值大于等于pivot，则j前移一个位置（即j- -）。重复该过程，直到找到第一个小于pivot的元素R[j]，将R[j]和R[i]进行交换，i++。其实交换后R[j]所对应的元素就是pivot。

令i自i位置开始向右扫描，如果i位置所对应的元素的值小于等于pivot，则i后移（即i++）。重复该过程，直至找到第一个大于pivot的元素R[i]，将R[i]与R[j]进行交换，j–。其实交换后R[i]所对应的元素就是pivot。

重复步骤3、4，交替改变扫描方向，从两端各自往中间靠拢直至i==j。此时i和j指向同一个位置，即基准元素pivot的最终位置。

《算法导论》上选择数组的尾元素为基准元素，采用单向扫描法确定pivotpos最终的位置。本篇博文也给出实现。但不再展开细谈。

三、C代码实现如下：

在快速排序中，partition函数有多种实现方式，主要分为“双向扫描”和“单向扫描”，在双向扫描中也有几种不同的实现方式。《算法导论》书上还提供了随机化版本、三数取中划分等版本，由于篇幅受限，不做介绍。

3.1 快速排序双向扫描法（一）

#include <stdio.h>#define MAX 100int array[MAX];//交换数组中两个元素位置void swap(int *a,int *b) {    int temp=*a;    *a=*b;    *b=temp;}int partition(int * Arr,int low,int high) {  //划分方法    //i和j分别指向数组下界和上界，pivot是待排的第一个元素    int i=low,j=high,pivot=Arr[low];    while (i<j) {        /* j自j位置开始向左扫面，如果j位置所对应的元素的值大于等于pivot，则j前移一个位置（即j--）。        重复该过程，直到找到第一个小于pivot的元素R[j]，将R[j]和R[i]进行交换，i++。        其实交换后R[j]所对应的元素就是pivot。*/        while (i<j && Arr[j]>=pivot) {            j--;        }        if (i<j) {            swap(&Arr[i++],&Arr[j]);//注意这里是交换元素，另外还有挖坑法实现，是元素覆盖。        }        /* 令i自i位置开始向右扫描，如果i位置所对应的元素的值小于等于pivot，则i后移（即i++）。        重复该过程，直至找到第一个大于pivot的元素R[i]，将R[i]与R[j]进行交换，j--。        其实，交换后R[i]所对应的元素就是pivot。*/        while (i<j  && Arr[i]<=pivot) {            i++;        }        if (i<j) {            swap(&Arr[i],&Arr[j--]);        }    }    /*此时i和j指向同一个位置，即基准元素pivot的最终位置。返回i的值*/    return  i;}void   QuickSort(int * Arr,int low,int high) {  //对数组Arr[low  high]进行快速排序    int pivotpos;                               //划分的基本元素所在的位置    if(low<high) {                              //区间长度大于1时才排序        pivotpos=partition(Arr,low,high);       //对Arr[low high]进行划分        QuickSort(Arr,low,pivotpos-1);        QuickSort(Arr,pivotpos+1,high);    }}void PrintArray(int arr[],int length) {         //打印数组，用于查看排序效果    printf("[");    for(int i=0; i<length; i++) {        if(i==length-1)            printf("%d]\n",arr[i]);        else            printf("%d ,",arr[i]);    }}int main() {    int num=0;    printf("请输入数组元素个数：");    scanf("%d",&num);    for(int i=0; i<num; i++) { //读入待排序数据        scanf("%d",&array[i]);    }    printf("排序前数据为：");    PrintArray(array,num);    QuickSort(array,0,num-1);    printf("排序后数据为：");    PrintArray(array,num);    return 0;}

3.2 partition函数双向扫描法（二）

int Partition(int * Arr,int low,int high)     {        int i = low, j = high;        int pivot = Arr[low]; //Arr[low]已经保存，可以被覆盖，即第一个坑        while (i < j)        {            // 从右向左找小于pivot的数来填Arr[low]            while(i < j && Arr[j] >= pivot)                 j--;              if(i < j)          {//将Arr[j]填到Arr[i]中，Arr[j]就形成了一个新的坑.              //这里不再是交换元素位置。              Arr[i] = Arr[j];                 i++;            }          // 从左向右找大于或等于pivot的数来填Arr[j]            while(i < j && Arr[i] < pivot)                i++;              if(i < j)             {                Arr[j] = Arr[i]; //将Arr[i]填到Arr[j]中，Arr[i]就形成了一个新的坑                j--;            }        }        //退出时，i等于j。将pivot填到这个坑中        Arr[i] = pivot;        //返回调整后基准数的位置      return i;    }

3.3 partition函数双向扫描法（三）

int Partition(int num[], int left, int right) {    int index = left + (right-left>>1);//注意：移位操作的优先级比加减法运算低    int temp = num[index];    num[index] = num[left];    while(left < right) {        while(left < right && temp <= num[right])            right--;        num[left] = num[right];        while(left < right && temp > num[left])            left++;        num[right] = num[left];    }    num[left] = temp;    return left;}

3.4 partition函数单向扫描法

int partition (int arr[], int p, int r){    int i = p - 1;    for (int j = p; j < r; j++)    {        if (arr[j] < arr[r])        {            swap(&arr[++i],&arr[j]);        }    }    swap(&arr[++i],&arr[r]);    return i;}

四、时间空间复杂度分析

空间复杂度：快速排序算法是递归执行，需要一个栈来存放每一层递归调用的必要信息，其最大容量应与递归调用的深度一致。最好的情况下，每次划分较为均匀，递归树的深度为O（logN），故递归所需要的栈空间为O（logN）。最坏情况下，递归树的高度为O（N），所需的栈空间为O（N）。平均情况下，所需栈空间为O（logN）。
时间复杂度： O(N*logN)。

五、动画演示

鄙人才疏学浅，制作不出动画演示。在此推荐日本程序员norahiko写的一个排序算法的动画演示，请戳链接h ttp://jsdo.it/norahiko/oxIy/fullscreen

1 0