排序算法之快速排序

1. 快速排序的基本思想
   快速排序使用分治的思想，通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

2. 快速排序的三个步骤
   1) 选择基准：在待排序列中，按照某种方式挑出一个元素，作为 “基准”（pivot）；
   2) 分割操作：以该基准在序列中的实际位置，把序列分成两个子序列。此时，在基准左边的元素都比该基准小，在基准右边的元素都比基准大；
   3) 递归地对两个序列进行快速排序，直到序列为空或者只有一个元素；

3. 选择基准元的方式
   对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。
   <1>选取第一个数组元素为基准元
   <2>选取数组元素中任一元素作为基准元
   <3>选取数组中间元素作为基准元
   一般来说，一般教材上将<1>作为样例。数据结构教材。作为数据结构当时没有入坑的人现在重新巩固快排算法。
   从整体来说。
   详细过程:

void qsort(int a[], int low, int high)
{
    if(low >= high)
    {
        return;
    }
    int first = low;
    int last = high;
    int key = a[first];/*用字表的第一个记录作为枢轴*/
    while(first < last)
    {
        while(first < last && a[last] >= key)
        {
            --last;
        }
        a[first] = a[last];/*将比第一个小的移到低端*/
        while(first < last && a[first] <= key)
        {
            ++first;
        }       
        a[last] = a[first];    
/*将比第一个大的移到高端*/
    }
    a[first] = key;/*枢轴记录到位*/
    qsort(a, low, first-1);
    qsort(a, first+1, high);
}

• 快排的实现

#include <iostream>
using namespace std;
void qsort(int a[], int low, int high)
{
    if(low >= high)
    {
        return;
    }
    int first = low;
    int last = high;
    int key = a[first];
    /*用字表的第一个记录作为枢轴*/
    while(first < last)
    {
        while(first < last && a[last] >= key)
        {
            --last;
        }
        a[first] = a[last];
        /*将比第一个小的移到低端*/
        while(first < last && a[first] <= key)
        {
            ++first;
        }       
        a[last] = a[first];    
         /*将比第一个大的移到高端*/
    }
    a[first] = key;/*枢轴记录到位*/
    qsort(a, low, first-1);
    qsort(a, first+1, high);
}
int main()
{
    int a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24 , 99 ,11,100,167,258,999,778,123,11,258,93 };
    qsort(a, 0, sizeof(a) / sizeof(a[0]) - 1);
    for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
     {
            cout << a[i] << "  ";
       }
    return 0;
}

• 快排取不同基准元

/*三种方法进行比较*/
#include <iostream>
#include <stdlib.h>
using namespace std;
void Swap(int *arr, int index1, int index2)
{
     int temp = arr[index1];
     arr[index1] = arr[index2];
     arr[index2] = temp;
}  
 int qsort(int *arr, int low, int high)
{
      if(low>=high)
      return 0;
      int first = low;
      int last = high;
      int key = arr[low];                             //取第一个元素作为基准元
   while (first < last)
     {
     while (first < last && arr[last] >= key)
          last--;
       arr[first] = arr[last];
     while (first < last && arr[first] <= key)
          first++;
       arr[last] = arr[first];
       }
       arr[first] = key;                               //基准元居中
       return first;
}
void qsort_base(int *arr, int low, int high)
{
 if (low >= high) return;                             //递归出口
 int partition = qsort(arr, low, high);      
 if(partition==0)   return;
  qsort_base(arr, partition + 1, high);
}
  void Partition_random(int *arr, int low, int high)
{
   int  rd=rand();
   int  index = rd% (high - low) + low;    //取数组中随机下标
   Swap(arr,index, low);                     //与第一个数交换
}
 void qsort_random(int *arr, int low, int high)
{
 if (low >= high) 
return;                                           //递归出口
 Partition_random(arr, low, high);                //随机基准元
  int partition = qsort(arr, low, high);      //将 >= x 的元素交换到右边区域，将 <= x 的元素交换到左边区域
  qsort_random(arr, low, partition - 1);
  qsort_random(arr, partition + 1, high);
}   
void Partition_mid(int  *arr, int low, int high)
{
    int mid = low + (high + -low) / 2;
      if (arr[mid] > arr[high])
        Swap(arr, mid, high);
      if (arr[low] > arr[high])
        Swap(arr, low, high);
      if (arr[mid] > arr[low])
         Swap(arr, mid, low);                                              
} 
  void  qsort_mid(int *arr, int low, int high)
{
  if (low >= high) return;                        //递归出口
  Partition_mid(arr, low, high);                   //三数取中
  int partition = qsort(arr, low, high);     
  qsort_mid(arr, low, partition - 1);
  qsort_mid(arr, partition + 1, high);
}
   int main()
{
   int a[] = {57, 68,  52, 72, 28, 96, 33, 24 , 99 ,11,100,167,258,999,778,123,11,258 };
     qsort_base(a, 0, sizeof(a) / sizeof(a[0]) - 1);
     //qsort_random(a, 0, sizeof(a) / sizeof(a[0]) - 1);
     //qsort_mid(a, 0, sizeof(a) / sizeof(a[0]) - 1);
    for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
     {
            cout << a[i] << "  ";
     }
    return 0;   
}
/*递归出口略有问题，仅供参考*/

• 时间复杂度分析
  假设一次划分所得枢轴位置 i=k，则对n 个记录进行快排所需时间：
  T(n) = Tpass(n) + T(k-1) + T(n-k)
  其中 Tpass(n)为对 n 个记录进行一次划分所需时间。
  若待排序列中记录的关键字是随机分布的，则 k 取 1 至 n 中任意一值的可能性相同。
  结论: 快速排序的时间复杂度为O(nlogn)

---