1 　　 /* 实现 Merge 函数，真正的做归并的操作了 */
 2     template <typename T>
 3     static void Merge(T src[], T helper[], int begin, int mid, int end, bool min2max)
 4     {
 5         int i = begin;  // 代表左边的起始位置
 6         int j= mid + 1;  // 代表右边的起始位置
 7         int k = begin;  // 代表辅助空间的起始位置
 8
 9         /* 对两路 for 循环的把控，这个 while 循环很经典 */
10         while( (i <= mid) && (j <= end) )  //  左边 i 和 右边 j 都还没有达到尾部
11         {
12             if( min2max ? (src[i] < src[j]) : (src[i] > src[j]) )  // min2max 真，将小的赋值到辅助空间，很经典
13             {
14                 helper[k++] = src[i++];  // 先将左边的元素放入辅助空间中，并继续在 while 中比较
15             }
16             else
17             {
18                 helper[k++] = src[j++];  // 右边的较小，放入辅助空间中
19             }
20         }
21
22         while( i <= mid )  // 当上面的某一路达到尾部没有了，而另一路还有元素的时候，当这一路是左边的元素时
23         {
24             helper[k++] = src[i++];// 直接将左边剩余空间中的元素拷贝到辅助空间中
25         }
26
27         while( j <= end )  // 当上面的某一路达到尾部没有了，而另一路还有元素的时候，当这一路是右边的元素时
28         {
29             helper[k++] = src[j++];// 直接将右边剩余空间中的元素拷贝到辅助空间中
30         }
31
32         for(i=begin; i<=end; i++)  // 将最终的元素全都从辅助空间拷贝到原始的空间中去
33         {
34             src[i] = helper[i];
35         }
36 　　 }
37
38     /* 二路归并排序,需要递归排序完成；第一个参数是需要归并排序的数据，第二个参数是归并排序的辅助空间，第三个参数是排序范围中的起始位置，第四个参数是排序范围中的结束位置；*/
39     template <typename T>  // 递归
40     static void Merge(T src[], T helper[], int begin, int end, bool min2max)
41     {
42          if( begin < end )  // 递归的出口，只有一个元素的时候，就是有序的，此时 begin == end；递归函数的参数自动的变化
43         {
44             int mid = (begin + end) / 2;  // 将需要排序的序列平均的分成两路，mid 之前是一路、之后是一路
45             Merge(src, helper, begin, mid, min2max);  // 对左边的这一路进行排序
46             Merge(src, helper, mid+1, end, min2max);  // 对右边的这一路进行排序
47             Merge(src, helper, begin, mid, end, min2max); // 对两路进行归并合并，从 begin 到 mid， 从 mid 到 end，并拷贝到原始数组
48         }
49 　　 }
50
51 　　/* 归并排序，这个函数对接口的处理很到位 */
52     template <typename T>  // 需要额外的空间才能完成，空间复杂度为 O(n)，时间复杂度为 O(n*logn)，稳定的排序法
53     static void Merge(T array[], int len, bool min2max = true)
54     {
55         T* helper = new T[len];  // 从堆空间申请待排序长度的辅助空间
56
57         /* 申请成功，进行具体的归并排序 */
58         if( helper != NULL )
59         {
60             Merge(array, helper, 0, len-1, min2max);
61         }
62
63         delete[] helper;
64 　　 }

 1 　　/* 快速排序的分割函数，返回值是下标，所以是 int，对数组 array[] 进行划分，二三两个参数为划分范围 */
 2     template <typename T>
 3     static int Partition(T array[], int begin, int end, bool min2max)
 4     {
 5         T pv = array[begin];  // 把第一个位置处的数据元素作为分割的基准
 6
 7         while( begin < end )  // 当begin和end相等的时候结束；这里一定会相等的
 8         {
 9             while( (begin < end) && (min2max ? (array[end] > pv) :(array[end] < pv)) ) // 实现不同顺序的排序
10             {
11                 end--;  // 当从最右边开始的数大于基准的时候，不交换位置，再换下一个位置比较
12             }
13
14             Swap(array[begin], array[end]);  // 把较小的数据元素放到前面，然后开始下面的较小端的比较，能够直接使 begin 先加 1，交换元素
15
16             while( (begin < end) && (min2max ? (array[begin] <= pv) : (array[begin] >= pv)) )  // 实现不同顺序的排序
17             {
18                 begin++;  // 当从最左边开始的数据元素小宇基准，不交换位置，再换下一个位置比较
19             }
20
21             Swap(array[begin], array[end]);  // 把较大的数据元素放到后面，然后开始下面的较大端的比较，能够直接使 end 再加 1
22         }
23
24         array[begin] = pv;  // 将分割的基准值放到合适的位置
25         return begin;  // 返回基准最终下标
26 　　 }
27
28     /* 递归实现快速排序 */
29     template <typename T>
30     static void Quick(T array[], int begin, int end, bool min2max )
31     {
32         if( begin < end )  // 起始位置小于终止位置，则待排序的序列他不是一个元素，进行递归；这里是为什么，是因为这里的递归递归到最后了，传进来的 begin 和 end 参数此时相等，已经不需要排序了
33     {
34             int pivot = Partition(array, begin, end, min2max);  // 基准最终所处//的位置
35             Quick(array, begin, pivot-1, min2max);  // 左边的位置进行快速排序；
36             Quick(array, pivot+1, end, min2max);  // 右边的位置进行快速排序；
37         }
38 　　 }
39
40 　　 /* 快速排序 */
41     template <typename T>  // 时间复杂度是 O(n*logn)，不稳定排序
42     static void Quick(T array[], int len, bool min2max = true)
43     {
44         Quick(array, 0, len-1, min2max);
45 　　 }
46     template <typename T>  // 时间复杂度是 O(n*logn)，不稳定排序
47     static void Quick(T array[], int len, bool min2max = true)
48     {
49         Quick(array, 0, len-1, min2max);
50 　　 }