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

目录：

• 一、快速排序思想介绍
• 二、实现的三步骤（分解、子问题求解、合并）
• 三、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 ]，该划分过程以第一个元素为基准元素。

1. 设定两个参数i和j，他们的初值分别为待排序列的下界和上界，即i=low，j=high。
2. 选取待排序列的第一个元素R[low]为基准元素，并将该值赋值给变量pivot。
3. 令j自j位置开始向左扫面，如果j位置所对应的元素的值大于等于pivot，则j前移一个位置（即j- -）。重复该过程，直到找到第一个小于pivot的元素R[j]，将R[j]和R[i]进行交换，i++。 其实交换后R[j]所对应的元素就是pivot。
4. 令i自i位置开始向右扫描，如果i位置所对应的元素的值小于等于pivot，则i后移（即i++）。重复该过程，直至找到第一个大于pivot的元素R[i]，将R[i]与R[j]进行交换，j–。其实交换后R[i]所对应的元素就是pivot。
5. 重复步骤3、4，交替改变扫描方向，从两端各自往中间靠拢直至i==j。此时i和j指向同一个位置，即基准元素pivot的最终位置。

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

---

三、C代码实现如下：

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

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

#include <stdio.h>
#define MAX 100
int 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