快速排序及其变种算法

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

1）  递归实现的快速排序算法

用分治法处理待排序数据，由于排序过程把数据分为两个部分，两个部分是独立处理的，所以可以用分治的方法处理两部分。

C++实现：

/****************************
 *Name:快速排序_递归.cpp
 *Tags:排序
 *Note:
 *****************************/
 
#include<iostream>
#defineMAX_SIZE 1000
usingnamespace std;
 
template<typename Type> void QuickSort(Type *, int, int);
template<typename Type> int Process(Type *, int, int);
 
intmain()
{
      int i, len, array[MAX_SIZE];
      cout << "Input the size of thearray: ";
      cin >> len;
      cout << "Start Input: "<< endl;
      for(i = 0; i < len; i++) {
    cin>> array[i];
      }
      QuickSort(array, 0, len-1); //快排
      cout << "After Sort :"<< endl;
      for(i = 0; i < len; i++) {
    cout<< array[i] << " ";
      }
      cout << endl;
      return 0;
}
 
template<typename Type>
voidQuickSort(Type *array, int start, int end)
{
      int k;
      if(start < end-1) {
    k =Process(array, start, end);
   QuickSort(array, start, k-1);
   QuickSort(array, k+1, end-1);
      }
} //递归过程
 
template<typename Type>
intProcess(Type *array, int i, int j)
{
      Type temp;
      temp = array[i];
      while(i < j) {
   while(j > i && array[j] >= temp) {
            j--;
    }
   array[i] = array[j];
   while(i < j && array[i] <= temp) {
            i++;
    }
   array[j] = array[i];
      }
      array[i] = temp;
      return i;
} //快排处理过程

在最坏的情况下，快速排序的时间复杂度为O(n^2)，快排的平均时间复杂度为O(nlogn)。

 

2）  随机快速排序

快速排序的最坏情况基于每次划分对主元的选择。基本的快速排序选取第一个元素作为主元。这样在数组已经有序的情况下，每次划分将得到最坏的结果。一种比较常见的优化方法是随机化算法，即随机选取一个元素作为主元。这种情况下虽然最坏情况仍然是O(n^2），但最坏情况不再依赖于输入数据，而是由于随机函数取值不佳。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n）。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn）的期望时间复杂度。

随机化快速排序的唯一缺点在于，一旦输入数据中有很多的相同数据，随机化的效果将直接减弱。对于极限情况，即对于n个相同的数排序，随机化快速排序的时间复杂度将毫无疑问的降低到O(n^2）

随机化快排的关键在于用rand函数获取随机位置

 

C++实现：

/****************************
 *Name:快速排序_随机化
 *Tags:排序 递归 随机
 *Note:
 *****************************/
 
#include<iostream>
#include<Cstdlib>
#defineMAX_SIZE 1000
usingnamespace std;
 
template<class Type> void QuickSort(Type *, int, int);
template<class Type> int Process(Type *, int, int);
 
intmain()
{
      int len, i, array[MAX_SIZE];
      cout << "Input the size of thearray: " ;
      cin >> len;
      cout << "Input Start"<< endl;
      for(i = 0; i < len; i++) {
            cin >> array[i];
      }
      cout << "Input End"<< endl;
      QuickSort(array, 0, len-1); //快速排序
      cout << "After Sort: "<< endl;
      for(i = 0; i < len; i++) {
            cout << array[i] << " ";
      }
      cout << endl;
      return 0;
}
 
template<class Type>
voidQuickSort(Type *array, int start, int end)
{
      int k;
      if(start < end) {
            k = Process(array, start, end);
            QuickSort(array, start, k-1);
            QuickSort(array, k+1, end); //递归处理
      }
}
 
template<class Type>
intProcess(Type *array, int i, int j)
{
      int r;
      Type temp;
      r = rand() % (j-i+1) + i; //获取随机位置
      temp = array[r];
      array[r] = array[i]; //获取随机位置的值
      array[i] = temp; //与第一个数交换位置
      while(i < j) {
            while(i < j && array[j] >= temp) {
                     j--;
            }
            array[i] = array[j];
            while(i < j && array[i] <= temp) {
                     i++;
            }
            array[j] = array[i];
      } //排序过程
      array[i] = temp;
      return i;
}

3) 平衡快排

平衡快排（BalancedQuicksort）：每次尽可能地选择一个能够代表中值的元素作为关键数据，然后遵循普通快排的原则进行比较、替换和递归。通常来说，选择这个数据的方法是取开头、结尾、中间3个数据，通过比较选出其中的中值。取这3个值的好处是在实际问题（例如信息学竞赛……）中，出现近似顺序数据或逆序数据的概率较大，此时中间数据必然成为中值，而也是事实上的近似中值。万一遇到正好中间大两边小（或反之）的数据，取的值都接近最值，那么由于至少能将两部分分开，实际效率也会有2倍左右的增加，而且利于将数据略微打乱，破坏退化的结构。

 

C++实现：

/****************************
 *Name:快速排序_平衡.cpp
 *Tags:排序 平衡
 *Note:
 *****************************/
 
#include <iostream>
#define MAX_SIZE 1000
using namespace std;
 
template <class Type> voidBalance_QuickSort(Type *, int, int);
template <class Type> intProcess(Type *, int, int);
template <class Type> intgetmiddle(Type *, int, int);
 
int main()
{
     int len, i, array[MAX_SIZE];
     cout << "Input the size of the array: ";
     cin >> len;
     for(i = 0; i < len; i++) {
             cin >> array[i];
     }
     Balance_QuickSort(array, 0, len-1); //排序
     cout << "After Sort: " << endl;
     for(i = 0; i < len; i++) {
             cout << array[i] << "";
     }
     cout << endl;
     return 0;
}
 
template <class Type>
void Balance_QuickSort(Type *array, intstart, int end)
{
     int x;
     if(start < end) {
             x = Process(array, start, end);
             Balance_QuickSort(array, start, x-1);
             Balance_QuickSort(array, x+1, end);
     } //递归处理
}
 
template <class Type>
int Process(Type *array, int i, int j)
{
     Type temp;
     int mild;
     mild = getmiddle(array, i, j); //获取中值
     temp = array[i];
     array[i] = array[mild];
     array[mild] = temp;
     temp = array[i];
     while(i < j) {
             while(i < j && array[j] >=temp) {
                     j--;
             }
             array[i] = array[j];
             while(i < j && array[i] <=temp) {
                     i++;
             }
             array[j] = array[i];
     } //排序过程
     array[i] = temp;
     return i;
}
 
template <class Type>
int getmiddle(Type *array, int i, int j)
{
     int mid = (i+j) / 2;
     if(array[mid] > array[i] && array[mid] < array[j] ||
          array[mid] < array[i] && array[mid]> array[j]) {
             return mid;
     }
     else if(array[i] > array[mid] && array[i] < array[j] ||
               array[i] < array[mid] &&array[i] > array[j]) {
             return i;
     }
     else return j;
} //获取中值