快速排序

  快速排序是除归并排序之外的有一种高级排序算法，时间复杂度为O(nlogn)，快速排序时交换排序的一种，是对冒泡排序作出的改进。冒泡排序每一都是相邻的两个元素进行比较和交换，每次交换只能消除一个逆序；而快速排序算法每次交换可以消除多个逆序，它的基本思想是：通过一趟排序将待排序列分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，直到整个序列都变成有序序列为止。

  C++实现快速排序的代码如下：

#include <iostream>

using namespace std;

//对arr[l...r]进行patition操作
//返回p，使得arr[l...p-1]<arr[p]，arr[p]>arr[p+1...r]
template<typename T>
int __patition(T arr[], int l, int r)
{
    int j = l;
    for(int i = l + 1; i <= r; i++)
    {
        if(arr[i] < arr[l])
        {
            swap(arr[j + 1], arr[i]);
            j++;
        }
    }
    swap(arr[l], arr[j]);
    return j;
}

template<typename T>
void __quickSort(T arr[], int l, int r)  //对arr[l...r]进行快速排序
{
    if(l >= r)
    {
        return;
    }
    else
    {
        int p = __patition(arr, l, r);  //__patition()函数将arr[l...r]分为两部分，该函数返回一个索引值
        __quickSort(arr, l, p - 1);
        __quickSort(arr, p + 1, r);
    }
}

template<typename T>
void quickSort(T arr[], int n)
{
    __quickSort(arr, 0, n - 1);
}

int main()
{
    int a[5] = {3, 5, 1, 6, 2};
    quickSort(a, 5);
    for(int i = 0; i < 5; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

  这里对__patition()的说明如下：

  若将快速排序和归并排序这两个O(nlogn)的算法进行比较，程序如下：

SortTestHelper.h文件（含辅助函数）

#include <iostream>
#include <cstdlib>
#include <ctime>  //clock()、CLOCKS_PER_SEC
#include <cassert>  //包含函数assert()

using namespace std;

namespace SortTestHelper
{
    //辅助函数 - 随机产生一个数组
    int* generateRandomArray(int n, int RangeL, int RangeR)  //返回数组首地址
    {
        //判断RangeL是否<=RangeR
        assert(RangeL <= RangeR);  //参数为表达式，表达式为真时返回true，否则打印错误信息

        int *arr = new int[n];
        srand(time(0));
        for(int i = 0; i < n ; i++)
        {
            arr[i] = rand() % (RangeR - RangeL + 1) + RangeL;  //使得产生的随机数在RangeL和RangeR之间
        }
        return arr;
    }

    //辅助函数 - 产生一个近乎有序的随机数组
    int* generateNearlyOrderedArray(int n, int swapTime)
    {
        int *arr = new int[n];
        for(int i = 0; i < n; i++)
        {
            arr[i] = i;  //先生成一个完全有序的数组
        }
        //然后交换几组元素，使之变成无序但近乎有序的数组
        srand(time(0));
        for(int j = 0; j < swapTime; j++)
        {
            //随机生成一个x位置和y位置
            int posx = rand() % n;
            int posy = rand() % n;
            //交换x和y处的元素
            swap(arr[posx], arr[posy]);
        }
        return arr;
    }

    //辅助数组 - 产生一个完全有序数组
    int* generateTotallyOrderedArray(int n)
    {
        int *arr = new int[n];
        for(int i = 0; i < n; i++)
        {
            arr[i] = i;
        }
        return arr;
    }

    //辅助函数 - 打印数组
    template<typename T>
    void printArray(T arr[], int n)
    {
        for(int i = 0; i < n; i++)
        {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

    //辅助函数 - 判断数组是否有序（升序）
    template<typename T>
    bool isSorted(T arr[], int n)
    {
        for(int i = 0; i < n - 1; i++)
        {
            if(arr[i] > arr[i + 1])
            {
                return false;
            }
        }
        return true;
    }

    //辅助函数 - 测试算法的时间
    template<typename T>
    void testSort(string sortname, void(*sort)(T[], int), T arr[], int n)  //arr[]和n是函数指针需要的参数
    {
        clock_t starttime = clock();
        sort(arr, n);  //调用函数sort()
        clock_t endtime = clock();

        //判断排序是否成功
        assert(isSorted(arr, n));  //若是数组无序，则assert会自动调用abort()退出程序，不会执行下面的语句

        cout << sortname << " needs " << double(endtime - starttime) / CLOCKS_PER_SEC << "s." << endl;
    }

    //辅助函数 - 拷贝数组
    int* copyIntArray(int a[], int n)
    {
        int *arr = new int[n];
        //使用C++函数copy()
        copy(a, a + n, arr);
        return arr;
    }
}

main.cpp文件（含归并排序算法和快速排序算法）

#include <iostream>
#include"SortTestHelper.h"

using namespace std;

//对arr[l...r]进行patition操作
//返回p，使得arr[l...p-1]<arr[p]，arr[p]>arr[p+1...r]
template<typename T>
int __patition(T arr[], int l, int r)
{
    int j = l;
    for(int i = l + 1; i <= r; i++)
    {
        if(arr[i] < arr[l])
        {
            swap(arr[j + 1], arr[i]);
            j++;
        }
    }
    swap(arr[l], arr[j]);
    return j;
}

template<typename T>
void __quickSort(T arr[], int l, int r)  //对arr[l...r]进行快速排序
{
    if(l >= r)
    {
        return;
    }
    else
    {
        int p = __patition(arr, l, r);  //__patition()函数将arr[l...r]分为两部分，该函数返回一个索引值
        __quickSort(arr, l, p - 1);
        __quickSort(arr, p + 1, r);
    }
}

template<typename T>
void quickSort(T arr[], int n)
{
    __quickSort(arr, 0, n - 1);
}

//归并排序
template<typename T>
void __merge(T arr[], int l, int mid, int r)  //[l...r]（前闭后闭）
{
    T aux[r - l + 1];
    for(int i = l; i <= r; i++)  //i是aux的下标
    {
        aux[i - l] = arr[i];
    }
    //i、j是arr中的下标,k是arr中的下标
    //i-l、j-l是aux中的下标
    int i = l, j = mid + 1, k = l;
    while(i <= mid && j <= r)
    {
        if(aux[i - l] < aux[j - l])
        {
            arr[k++] = aux[i - l];
            i++;
        }
        else
        {
            arr[k++] = aux[j - l];
            j++;
        }
    }
    //出界条件
    while(i <= mid)
    {
        arr[k++] = aux[i - l];
        i++;
    }
    while(j <= r)
    {
        arr[k++] = aux[j - l];
        j++;
    }
}
template<typename T>
void __mergeSort(T arr[], int l, int r)
{
    if(l >= r)
    {
        return;
    }
    else
    {
        int mid = (l + r) / 2;
        //对左半部分arr[l...mid]进行归并排序
        __mergeSort(arr, l, mid);
        //再对右半部分arr[mid + 1...r]进行归并排序
        __mergeSort(arr, mid + 1, r);
        //然后将排好序的左右两部分归并到一起
        __merge(arr, l, mid, r);
    }
}
template<typename T>
void mergeSort(T arr[], int n)
{
    //传递一个数组，调用归并排序算法归并arr[0...n-1]
    __mergeSort(arr, 0, n - 1);
}

int main()
{
    int n = 500000;
    int *arr = SortTestHelper::generateRandomArray(n, 0, n);
    int *arr2 = SortTestHelper::copyIntArray(arr, n);
    SortTestHelper::testSort("mergeSort", mergeSort, arr, n);
    SortTestHelper::testSort("qucikSort", quickSort, arr2, n);
    delete[] arr;
    delete[] arr2;
    return 0;
}

  测试结果显示，快排和归并排序的时间性能差不多，但是快排的时间性能更好。

  可以看出快排的时间性能很好，但是实际上快排任然存在一些局限性，但是存在优化方法，这些内容将会在下一节出现。