【每日算法】交换排序算法之快速排序

恩，重头戏开始了，快速排序是各种笔试面试最爱考的排序算法之一，且排序思想在很多算法题里面被广泛使用。是需要重点掌握的排序算法。

1）算法简介

快速排序是由东尼·霍尔所发展的一种排序算法。其基本思想是基本思想是，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

2）算法描述和分析

快速排序使用分治法来把一个串（list）分为两个子串行（sub-lists）。

步骤为：
1、从数列中挑出一个元素，称为 "基准"（pivot），
2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

算法伪代码描述：

function quicksort(q)
    var list less, pivotList, greater
    if length(q) ≤ 1 {
        return q
    } else {
        select a pivot value pivot from q
        for each x in q except the pivot element
            if x < pivot then add x to less
            if x ≥ pivot then add x to greater
            add pivot to pivotList
        return concatenate(quicksort(less), pivotList, quicksort(greater))
    }

在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

最差时间复杂度: O(n^2)
最优时间复杂度: O(n log n)
平均时间复杂度: O(n log n)
最差空间复杂度: 根据实现的方式不同而不同

3）算法图解、flash演示、视频演示

图解：
快速排序会递归地进行很多轮，其中每一轮称之为快排的partition算法，即上述算法描述中的第2步，非常重要，且在各种笔试面试中用到该思想的算法题层出不穷，下图为第一轮的partition算法的一个示例。

Flash：
可一步步参见http://ds.fzu.edu.cn/fine/resources/FlashContent.asp?id=86中的快排过程
视频 舞动的排序算法
http://v.youku.com/v_show/id_XMzMyODk4NTQ4.html

4）算法代码

    事实上，这个地方需要提一下的是，快排有很多种版本。例如，我们“基准数”的选择方法不同就有不同的版本，但重要的是快排的思想，我们熟练掌握一种版本，在最后的笔试面试中也够用了，我这里罗列几种最有名的版本C代码。

1、版本一
我们选取数组的第一个元素作为主元，每一轮都是和第一个元素比较大小，通过交换，分成大于和小于它的前后两部分，再递归处理。

代码如下

/************************************************** 
  函数功能：对数组快速排序                        
  函数参数：指向整型数组arr的首指针arr；           
            整型变量left和right左右边界的下标    
  函数返回值：空                                   
/**************************************************/  
void QuickSort(int *arr, int left, int right)  
{  
  int i,j;  
  if(left<right)  
  {  
    i=left;j=right;  
    arr[0]=arr[i]; //准备以本次最左边的元素值为标准进行划分，先保存其值  
    do  
    {  
      while(arr[j]>arr[0] && i<j)   
        j--;        //从右向左找第1个小于标准值的位置j  
      if(i<j)                               //找到了，位置为j  
      {   
        arr[i] = arr[j];  
        i++;  
      }           //将第j个元素置于左端并重置i  
      while(arr[i]<arr[0] && i<j)  
        i++;      //从左向右找第1个大于标准值的位置i  
      if(i<j)                       //找到了，位置为i  
      {   
        arr[j] = arr[i];  
        j--;  
      }           //将第i个元素置于右端并重置j  
    }while(i!=j);  
    arr[i] = arr[0];         //将标准值放入它的最终位置,本次划分结束  
    quicksort(arr, left, i-1);     //对标准值左半部递归调用本函数  
    quicksort(arr, i+1, right);    //对标准值右半部递归调用本函数  
  }  
}  

2、版本二
随机选基准数的快排

//使用引用，完成两数交换  
void Swap(int& a , int& b)  
{  
 int temp = a;  
 a = b;  
 b = temp;  
}  
//取区间内随机数的函数  
int Rand(int low, int high)  
{  
 int size = hgh - low + 1;  
 return  low + rand()%size;   
}  
    //快排的partition算法，这里的基准数是随机选取的  
int RandPartition(int* data, int low , int high)  
{      
 swap(data[rand(low,high)], data[low]);//  
 int key = data[low];  
 int i = low;  
   
 for(int j=low+1; j<=high; j++)  
 {  
  if(data[j]<=key)  
  {  
   i = i+1;  
   swap(data[i], data[j]);  
  }              
 }   
 swap(data[i],data[low]);  
 return i;  
}  
//递归完成快速排序  
void QuickSort(int* data, int low, int high)  
{  
 if(low<high)  
 {  
  int k = RandPartition(data,low,high);  
  QuickSort(data,low,k-1);  
  QuickSort(data,k+1,high);  
 }  
}  

5）考察点，重点和频度分析

完全考察快排算法本身的题目，多出现在选择填空，基本是关于时间空间复杂度的讨论，最好最坏的情形交换次数等等。倒是快排的partition算法需要特别注意！频度极高地被使用在各种算法大题中！详见下小节列举的面试小题。

6）笔试面试例题

这里要重点强调的是快排的partition算法，博主当年面试的时候就遇到过数道用该思路的算法题，举几道如下：

例题1、最小的k个数，输入n个整数，找出其中最下的k个数，例如输入4、5、1、6、2、7、3、8、1、2，输出最下的4个数，则输出1、1、2、2。

当然，博主也知道这题可以建大小为k的大顶堆，然后用堆的方法解决。

但是这个题目可也以仿照快速排序，运用partition函数进行求解，不过我们完整的快速排序分割后要递归地对前后两段继续进行分割，而这里我们需要做的是判定分割的位置，然后再确定对前段还是后段进行分割，所以只对单侧分割即可。代码如下：

void GetLeastNumbers_by_partition(int* input, int n, int* output, int k)  
{  
    if(input == NULL || output == NULL || k > n || n <= 0 || k <= 0)  
        return;  
    int start = 0;  
    int end = n - 1;  
    int index = Partition(input, n, start, end);  
    while(index != k - 1)  
    {  
        if(index > k - 1)  
        {  
            end = index - 1;  
            index = Partition(input, n, start, end);  
        }  
        else  
        {  
            start = index + 1;  
            index = Partition(input, n, start, end);  
        }  
    }  
    for(int i = 0; i < k; ++i)  
        output[i] = input[i];  
}  

例题2、判断数组中出现超过一半的数字

当然，这道题很多人都见过，而且最通用的一种解法是数对对消的思路。这里只是再给大家提供一种思路，快排partition的方法在很多地方都能使用，比如这题。我们也可以选择合适的判定条件进行递归。代码如下：

bool g_bInputInvalid = false;  
bool CheckInvalidArray(int* numbers, int length)  
{  
    g_bInputInvalid = false;  
    if(numbers == NULL && length <= 0)  
        g_bInputInvalid = true;  
    return g_bInputInvalid;  
}  
bool CheckMoreThanHalf(int* numbers, int length, int number)  
{  
    int times = 0;  
    for(int i = 0; i < length; ++i)  
    {  
        if(numbers[i] == number)  
            times++;  
    }  
    bool isMoreThanHalf = true;  
    if(times * 2 <= length)  
    {  
        g_bInputInvalid = true;  
        isMoreThanHalf = false;  
    }  
    return isMoreThanHalf;  
}  
int MoreThanHalfNum_Solution1(int* numbers, int length)  
{  
    if(CheckInvalidArray(numbers, length))  
        return 0;  
    int middle = length >> 1;  
    int start = 0;  
    int end = length - 1;  
    int index = Partition(numbers, length, start, end);  
    while(index != middle)  
    {  
        if(index > middle)  
        {  
            end = index - 1;  
            index = Partition(numbers, length, start, end);  
        }  
        else  
        {  
            start = index + 1;  
            index = Partition(numbers, length, start, end);  
        }  
    }  
    int result = numbers[middle];  
    if(!CheckMoreThanHalf(numbers, length, result))  
        result = 0;  
    return result;  
}  

例题3、有一个由大小写组成的字符串，现在需要对他进行修改，将其中的所有小写字母排在大写字母的前面(不要求保持原顺序)
这题可能大家都能想到的方法是：设置首尾两个指针，首指针向后移动寻找大写字母，尾指针向前移动需找小写字母，找到后都停下，交换。之后继续移动，直至相遇。这种方法在这里我就不做讨论写代码了。

但是这题也可以采用类似快排的partition。这里使用从左往后扫描的方式。字符串在调整的过程中可以分成两个部分：已排好的小写字母部分、待调整的剩余部分。用两个指针i和j，其中i指向待调整的剩余部分的第一个元素，用j指针遍历待调整的部分。当j指向一个小写字母时，交换i和j所指的元素。向前移动i、j，直到字符串末尾。代码如下：

#include <iostream>  
using namespace std;  

void Proc( char *str ) {  
    int i = 0;  
    int j = 0;  
    //移动指针i, 使其指向第一个大写字母  
    while( str[i] != '' && str[i] >= 'a' && str[i] <= 'z' ) i++;  
    if( str[i] != '' ) {  
        //指针j遍历未处理的部分，找到第一个小写字母  
        for( j=i; str[j] != ''; j++ ) {  
            if( str[j] >= 'a' && str[j] <= 'z' ) {  
                char tmp = str[i];  
                str[i] = str[j];  
                str[j] = tmp;  
                i++;  
            }  
        }  
    }  
}  

int main() {  
    char data[] = "SONGjianGoodBest";  
    Proc( data );  
    return 0;  
}