快速排序算法在C++中的实现（其实是C语言实现）

C++快速排序的实现

本次主要简单介绍一下快速排序的算法原理以及在C++下的实现。
快速排序原理
   快速排序算法属于分治算法的一种实现，排序的思路是将待排序的数组分为两部分，其中第一部分的值小于数组中选定的一个标准值，而另一部分的值大于该选定的标准值，然后再将第一部分与第二部分分别进行快速排序，容易推断出当快速排序算法退出时待排序数组将变成有序的。
   快速排序的关键是选对用于比较的标准值，《数据结构与算法分析C语言描述》一书中提到这个标准值的选定可使用三值中分的方法，该方法原理是比较待排序数组的起始下标的元素，终止下标的元素以及下标为数组二分之一长度的元素，然后将三值中最小值放置于起始下标处，最大值置于终止下标处，中间值位于数组中间位置。
   快速排序是目前实践已知的平均时间复杂度最低的算法，其平均时间复杂度为$N*logN$,而且有人已经证明了这就是排序算法的时间下限，意味着不会有比这更快的排序算法了。
快速排序的实现
   说了这么些，让我们结合代码看一下这个算法的实现吧，关于该算法的详细信息请参考维基百科Quicksort。首先是快速排序的头文件，在该文件中声明了快速排序提供的对外接口，以及内部实现用到的方法。

#pragma once
template <class DataType>
class QuickSort
{
public:
    QuickSort();
    ~QuickSort();
    // 类对外提供的方法
    void Sort(DataType* Array,int Length);
private:
    DataType Median3(DataType* Array, int low, int high);
    // 插入排序 当数组长度小于5时使用插入排序更方便
    void InsertSort(DataType* Array, int low, int high);
    // 快速排序主算法
    void MyQuickSort(DataType* Array, int low, int high);
    // 数据交换函数
    void Swap(DataType* Array, int low, int high);
};

   接下来就是快速排序的实现文件了，在这里我们可以看到Median3(DataType* Array, int low, int high) 这个方法的作用就是实现三值中分。

#include "QuickSort.h"
#define MinLength 3
template <class DataType>
QuickSort<DataType>::QuickSort()
{
}


template <class DataType>
QuickSort<DataType>::~QuickSort()
{
}


// 类对外提供的方法
template <class DataType>
void QuickSort<DataType>::Sort(DataType* Array,int Length)
{
    MyQuickSort(Array, 0, Length - 1);
}
//三值中分方法确认数据标记
template <class DataType>
DataType QuickSort<DataType>::Median3(DataType* Array, int low, int high)
{
    int center = (low + high) / 2;
    if (Array[low] > Array[center])
        Swap(Array, low, center);
    if (Array[low] > Array[high])
        Swap(Array, low, high);
    if (Array[center] > Array[high])
        Swap(Array, center, high);
    //以上交换确保Array[low]<Array[center]<Array[high]
    Swap(Array, center, high-1);
    return Array[high-1];
}

template <class DataType>
// 插入排序 当数组长度小于4时使用插入排序更方便
void QuickSort<DataType>::InsertSort(DataType* Array, int low,int high)
{
    DataType temp;
    int i,j;
    for (i = low+1; i <=high; i++)
    {
        temp = Array[i];
        for (j = i; j > low && temp < Array[j - 1]; j--)
            Array[j] = Array[j - 1];
        Array[j] = temp;
    }
}
template <class DataType>
// 快速排序主算法
void QuickSort<DataType>::MyQuickSort(DataType* Array, int low, int high)
{
    if (low + MinLength < high)
    {
        DataType pivot = Median3(Array, low, high);
        int i=low, j=high-1;
        for (;;)
        {
            while (Array[++i] < pivot);
            while (Array[--j] > pivot);
            if (i < j)
                Swap(Array, i, j);
            else
                break;
        }
        Swap(Array, i, high-1);
        MyQuickSort(Array, low, i-1);
        MyQuickSort(Array, i + 1, high);
    }
    else
    {
        InsertSort(Array, low, high);
    }
}

template <class DataType>
// 数据交换函数
void QuickSort<DataType>::Swap(DataType* Array, int low,int high)
{
    DataType temp;
    temp = Array[low];
    Array[low] = Array[high];
    Array[high] = temp;
}

    然后就是测试算法的文件了，这里我们写得比较简单。

#include"QuickSort.cpp"
#include<iostream>
using namespace std;
int main()
{
    //测试数组
    int IntTest[10] = {0,3,5,6,4,2,1,9,8,7};
    QuickSort<int> Test = QuickSort<int>();
    cout <<"Before Sort:" << endl;
    for (int i = 0; i < 10; i++)
        cout << IntTest[i] << "  ";
    cout << endl;
    Test.Sort(IntTest, 10);
    cout << "After Sort:" << endl;
    for (int i = 0; i < 10; i++)
        cout << IntTest[i] << "  ";
    cout << endl;
}

    以下是算法测试的结果。