<C/C++算法> 八大经典排序算法的性能对比与总结

本文链接：https://blog.csdn.net/ebowtang/article/details/29882715

一，各排序算法的思想及其稳定性

以下排序算法的排序结果若无特殊说明均为升序，swap函数的具体实现如下，每次的排序算法不再重复。（吐槽：多年后的今天来看，尼玛，都忘了，看不懂了！真佩服自己）

void swap(int *a, int i, int j) //交换两个数  
{
        if(i==j)
           return;
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

1，八大经典排序算法

(1)冒泡排序

依次比较相邻的数据，将小数据放在前，大数据放在后；即第一趟先比较第1个和第2个数，大数在后，小数在前，再比较第2个数与第3个数，大数在后，小数在前，以此类推则将最大的数"滚动"到最后一个位置；第二趟则将次大的数滚动到倒数第二个位置......第n-1(n为无序数据的个数)趟即能完成排序。
以下面5个无序的数据为例：
40 8 15 18 12 （文中仅细化了第一趟的比较过程）
第1趟: 8 15 18 12 40
第2趟: 8 15 12 18 40
第3趟: 8 12 15 18 40
第4趟: 8 12 15 18 40

void bubblesort(int *arr,int nsize)
{
	//排序，从i开始排，总是在[i+1,nsize]去寻找比当前元素小的，并且交换，使得当前位置的值总是其后面最小的。
	for (int i = 0; i < nsize; i++)
		for (int j = i + 1; j < nsize; j++)
			if (arr[i] > arr[j]) swap(arr, i,j);
}

(2)选择排序

以升序为例，比如在一个长度为N的无序数组中，
在第一趟遍历N个数据，找出其中最小的数值与第一个元素交换，
第二趟遍历剩下的N-1个数据，找出其中最小的数值与第二个元素交换......
第N-1趟遍历剩下的2个数据，找出其中最小的数值与第N-1个元素交换，
至此选择排序完成。
以下面5个无序的数据为例：
56 12 80 91 20（文中仅细化了第一趟的选择过程）
第1趟：12 56 80 91 20
第2趟：12 20 80 91 56
第3趟：12 20 56 91 80
第4趟：12 20 56 80 91

核心函数：

void selectsort(int *arr, int nsize)
{
	for (int i = 0; i < nsize; i++)
	{
		//arr[i+1....nsize-1]中找到当前最小值及其位置（准备与当前a[i]调换）  
		int min = arr[i];
		int minpos = i;
		for (int j = i + 1; j < nsize; j++)
		{
			if (arr[j] < min)
			{
				min = arr[j]; //当前最小值  
				minpos = j;//记录当前最小值的位置  
			}
		}
		swap(arr, i, minpos);//交换最小值位置，a[0....i]已经有序
	}
}

tip：

冒泡法和选择排序很像，两者区别在于：

冒泡排序是每一次都可能要交换，而选择排序是在比较时记下a[i]的位置最后来交换

所以他们的交换过程是不一样的，但查找的过程是一样的。

所以选择排序的效率比冒泡法只高不低...

(3)插入排序
像扑克摸牌一样，插入即表示将一个新的数据插入到一个有序数组中，并继续保持有序。例如有一个长度为N的无序数组，进行N-1次的插入即能完成排序；第一次，数组第1个数认为是有序的数组，将数组第二个元素插入仅有1个有序的数组中；第二次，数组前两个元素组成有序的数组，将数组第三个元素插入由两个元素构成的有序数组中......第N-1次，数组前N-1个元素组成有序的数组，将数组的第N个元素插入由N-1个元素构成的有序数组中，则完成了整个插入排序。
以下面5个无序的数据为例：
65 27 59 64 58 （文中仅细化了第四次插入过程）
第1次插入: 27 65 59 64 58
第2次插入: 27 59 65 64 58
第3次插入: 27 59 64 65 58
第4次插入: 27 58 59 64 65

void insertsort(int *arr, int nsize)
{
	int i, j, key;
	for (i = 1; i<nsize; i++)//控制需要插入的元素
	{
		key = arr[i]; //key为当前要插入的元素，将其插入到有序段arr[0,i-1]
		j = i - 1;
		while (j >= 0 && arr[j] > key) //查找要插入的位置,循环结束时则找到插入位置j
		{
			arr[j+1] = arr[j]; //移动元素的位置.供要插入元素使用
			j--;
		}
		arr[j+1] = key; //插入指定元素到指定位置
	}
}

(4)快速排序
快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，该方法的基本思想是：
1．先从数列末尾取出一个数作为基准元。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

//手动快速默写快排：先划界，再分治....  
int quickPartion(int *arr, int low, int high)
{
	int pos = rand() % (high - low + 1) + low;
	swap(arr, pos, high);//将末尾的元素随机化,防止极端情况  
	int key = arr[high];//总是将末尾元素选为关键化界元
	int i = low - 1;//总是记录比key小的元素最前面的位置
	for (int j = low; j <= high - 1; j++)
	{
		if (arr[j] <= key)
			swap(arr, ++i, j);
	}
	swap(arr, ++i, high);
	return i;//返回“中间位置”
}

void QuickSort(int *arr, int low, int high)
{
	if (low < high)
	{
		int mid = quickPartion(arr, low, high);
		QuickSort(arr, low, mid - 1);
		QuickSort(arr, mid + 1, high);
	}
}

(5)归并排序
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

核心函数：

//分治法的合并函数  
//arr[low...mid]与arr[mid+1...high]相合并
void Merge(int *arr, int low, int mid, int high)
{
	int leftlen = mid - low + 1;//arr[low...mid]的长度
	int rightlen = high - mid;//arr[mid+1...high]的长度

	int *L = new int[leftlen + 1];//每次归并时都在动态申请内存，这里可以优化
	int *R = new int[rightlen + 1];
	L[leftlen] = INT_MAX;//末尾均是哨兵元素    
	R[rightlen] = INT_MAX;
	//赋值，准备有序放入arr[low.....high]
	int i = 0;
	for (; i < leftlen; i++)
		L[i] = arr[low + i];
	
	int j = 0;
	for (; j < rightlen; j++)
		R[j] = arr[mid + j + 1];

	//有序放入arr[low.....high]
	i = 0; j = 0;
	for (int k = low; k <= high; k++)
	{
		if (L[i] <= R[j])//谁更小，谁就放入arr[k]中
			arr[k] = L[i++];
		else
			arr[k] = R[j++];
	}

	delete[] L; L = NULL;
	delete[] R; R = NULL;
}

//合并排序法（分治法）  
void MergeSort(int *arr, int low, int high)
{
	if (low < high)
	{
		int mid = (low + high) / 2;
		MergeSort(arr, low, mid);
		MergeSort(arr, mid + 1, high);
		Merge(arr, low, mid, high);
	}
}

(6)希尔排序(shell)
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

//希尔排序  
void ShellSort(int *a,int nlen)
{
	int gap = nlen ;
	while (gap>1)
	{
		gap = gap / 3 + 1;
		for (int i = gap; i < nlen; ++i)
		{
			int temp = a[i]; //暂存关键数据  
			int j = i;
			while (j - gap >= 0 && temp < a[j - gap])
			{
				a[j] = a[j - gap];   //后移  
				j = j - gap;     //前置索引  
			}
			a[j] = temp;
		}
	}
}

(7)堆排序
我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。

//保持堆的性质  
//在数组arr中以位置i为入口维护最大堆性质（根节点总是更大）
void  KeepMaxHeap(int *a, int i, int heapsize)  //使a[i]这个元素下降（如果不满足最大根要求的话）    
{
	int l = 2*i+1;
	int r = 2*i+2;

	//找到当前入口位置i及其左右子之间的较大者，如果不是当前i位置的值最大，将会交换并重新开始调整
	int largest =i;
	
	if (l <= heapsize && a[l]>a[i])//与左子比  
		largest = l;

	if (r <= heapsize && a[r]>a[largest])//将较大者与右子比  
		largest = r;
	
	if (largest != i)
	{
		swap(a,i,largest);
		KeepMaxHeap(a, largest, heapsize);
	}
}

//创建堆,将数组调整为最大堆  
void BuildMaxHeap(int *a,int nsize)
{
	int heapsize = nsize - 1;
	for (int i = heapsize / 2; i >= 0; i--)
		KeepMaxHeap(a, i, heapsize);//heapsize/2+1到a.size-1的整数都是树叶，所以只需对0到heapsize/2作处理  
}

//堆排序  
void  HeapSort(int *a,int nsize)
{
	BuildMaxHeap(a,nsize);//使数组成为最大堆  
	int heapsize = nsize-1;
	for (int i = nsize - 1; i>0; i--)
	{
		swap(a,0, i);
		heapsize--;//叶子将逐渐“脱离”
		KeepMaxHeap(a, 0, heapsize);//保持堆的性质  
	}
}

(8)计数排序
假设数序列中小于元素a的个数为n，则直接把a放到第n+1个位置上。当存在几个相同的元素时要做适当的调整，因为不能把所有的元素放到同一个位置上。计数排序假设输入的元素都是0到k之间的整数。
计数排序算法没有用到元素间的比较，它利用元素的实际值来确定它们在输出数组中的位置。因此，计数排序算法不是一个基于比较的排序算法，从而它的计算时间下界不再是Ω(nlogn)。
对每一个输入元素x，确定小于x的元素的个数，那样排序之后，x在最终输出数组中的位置就可以确定了。

例如：如果有17个元素小于x，则x就位于第18个输出的位置上。

//计数排序  
void CountSort(int *a, int len)
{
	int nLen = len;

	int* Cout = new int[nLen];    //申请空间,用于计数,被排序的数一定要是[0,nLen-1]之间的数（可包括） 
	//初始化记数为0  
	for (int i = 0; i < nLen; ++i)
		Cout[i] = 0;

	//统计元素出现次数计数。即数组元素a[i]的出现次数,将其结果存放在Cout[a[i]]中。  
	for (int i = 0; i < nLen; ++i)
		++Cout[a[i]];

	//统计小于等于当前位置i的元素个数  
	for (int i = 1; i < nLen; ++i)
		Cout[i] += Cout[i - 1];

	int* Sort = new int[nLen];    //申请空间，用于存放排序结果  

	for (int i = 0; i < nLen; ++i)
	{
		//把数据放在指定位置。因为pCout[pData[i]]的值就是不比他大数据的个数。  
		//为什么要先减一，因为pCout[pData[i]]保存的是不比他大数据的个数中包括了  
		//他自己，我的下标是从零开始的!所以要先减一。  
		--Cout[a[i]];    //因为有相同数据的可能，所以要把该位置数据个数减一。  
		Sort[Cout[a[i]]] = a[i];

	}

	//排序结束，复制到原来数组中。  
	for (int i = 0; i < nLen; ++i)
		a[i] = Sort[i];

	//释放申请的空间。  
	delete[] Cout;
	Cout = NULL;
	delete[] Sort;
	Sort = NULL;
}

2，排序算法小结

综上，得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，
而冒泡排序、插入排序、计数排序、归并排序和基数排序是稳定的排序算法。还有一些排序算法我没有进行

二，C++模板实现

1,程序说明

1），本程序实现了若干经典排序算法性能（运行时间）比较

2），实现了在不同规模（元素个数）下的性能比较

3），实现了对移动次数和比较次数的统计（间接说明性能）

4），实现了数据混乱类型的选择

注：本程序有可能有bug，非绝对正确，发现过错误，未调试完！

2,AllSort.h代码如下

#include "iostream"
#include "vector"
using namespace std;

template<class DataType>  
class AllSort  
{  
public:  
	AllSort()
	{
		//移动次数初始化
		countSortMove=0;
		//比较次数初始化
		countSortCmp=0;
		//初始化数据时的不重复个数
		countNum=5;
	}
	~AllSort()
	{

	}
	//打印数组
	void printArray(vector<DataType> &a,bool isPrint);
	//交换元素  
	void swap(DataType *a,DataType *b);
	//初始化数组
	void InitArr(vector<DataType> &a,int len,int arrType);
	//冒泡排序法
	void BubbleSort(vector<DataType> &a, int l, int r, bool Up=true);
	//插入排序法
	void InsertSort(vector<DataType> &a, int l, int r, bool Up=true);
	//快速排序法
	void QuickSort(vector<DataType> &a, int l, int r, bool Up=true);
	//划界
	int Partition(vector<DataType> &a, int l, int r, bool Up=true);
	//随机快速排序法
	void RandQuickSort(vector<DataType> &a, int l, int r, bool Up=true);
	//随机划界
	int RandPartition(vector<DataType> &a, int l, int r, bool Up=true);
	//三者取中快速排序法
	void thrWayQuickSort(vector<DataType> &a, int l, int r, bool Up=true);
	//三者取中划界
	int thrWayPartition(vector<DataType> &a, int l, int r, bool Up=true);
	//分而治之排序法
	void MergeSort(vector<DataType> &a, int l, int r, bool Up=true);
	void Merge(vector<DataType> &a, int p, int q, int r,bool Up=true);
	//计数排序
	void CountSort(vector<DataType> &a,int arrType,int len,bool Up=true); 
	//洗牌策略随机打乱一个数组中的n个元素 
	void randArray(vector<DataType> &a, unsigned int n,int isRand);
	//选择排序法
	void SelectSort(vector<DataType> &a, int l, int r, bool Up=true);
	//希尔排序
	void ShellSort(vector<DataType> &a,int low, int high,bool Up=true);
	//堆中的左子
	int Left(int i);
	//堆中的右子
	int Right(int i);
	//保持堆性质
	void KeepMaxHeap(vector<DataType> &a, int len,int heapsize,bool Up);
	//建堆
	void BuildMaxHeap(vector<DataType> &a,bool Up);
	//堆排序
	void HeapSort(vector<DataType> &a,bool Up);

	int getSortCount(bool IsMove)
	{
		if (IsMove)
		{
			return countSortMove;
		}else
		{
			return countSortCmp;
		}
	}
	void beforSort()
	{
		//移动次数初始化
		countSortMove=0;
		//比较次数初始化
		countSortCmp=0;
	}

private:
	//移动次数
	int countSortMove;
	//比较次数
	int countSortCmp;
	//初始化数据时的不重复数据个数
	int countNum;
};

//交换元素
template <typename DataType>    
void AllSort<DataType>::swap(DataType *a,DataType *b)
{
	DataType temp;
	temp =*a;
	*a=*b;
	*b=temp;
}

//交换元素
template <typename DataType>    
void AllSort<DataType>::InitArr(vector<DataType> &a,int len,int arrType)
{
	if (arrType == 1)
	{
		for (int i=0;i<len;i++)
		{
			a.push_back(i);
		}
	}else if(arrType == 2)
	{
		for (int i=0;i < len;i++)
		{
			int key=i%countNum;
			a.push_back(key);
		}
	}
}

// 随机打乱一个数组n个元素
template <typename DataType>   
void  AllSort<DataType>::randArray(vector<DataType> &a,unsigned int n,int isRand)
{
	if ( n > a.size() )
	{
		cerr<<"无法打乱指定数量的元素"<<endl;
		exit(1);
	}
	if (isRand == 1)//随机打乱
	{
		unsigned int index, i;
		for (i = 0; i < n; i++)//将数组中的每一个元素都进行随即打乱
		{
			index = rand() % n;//残生0到n-1之间的随机位置数
			if (index != i)
			{
				swap(&a[i],&a[index]);
			}
		}
	}else if(isRand == 2)//升序
	{
		bool upflag=true;
		this->ShellSort(a,0,a.size()-1,upflag);
	}else if(isRand == 3) //降序
	{
		bool upflag=false;
		this->ShellSort(a,0,a.size()-1,upflag);
	}else if(isRand == 4)
	{
		unsigned int gap=5;
		unsigned int index, i;
		for (i = 0; i < n; i++)//将数组中的每一个元素都进行随即打乱
			{
				index = rand()%gap + i;//残生i到j之间的随机位置数
				if ( index != i&& index < n)
				{
					swap(&a[i],&a[index]);
				}
			}
	}else
	{
		cerr<<"isRand参数错误！来自randArray（）函数"<<endl;
		return;
	}
}

//打印数组
template <typename DataType>  
void  AllSort<DataType>::printArray(vector<DataType> &a,bool isPrint)
{
	
	if (isPrint)
	{
		cout<<"排序或打乱结果为： ";
		for(unsigned int i = 0; i < a.size(); i++ )  
		{
			cout << a[ i ]<<" ";  
			if ((i+1)%27 == 0)
			{
				cout<<endl;
			}
		}
		cout<<endl;
	}
}

//希尔排序
template <typename DataType>  
void AllSort<DataType>::ShellSort(vector<DataType> &a,int low, int high,bool Up)
{
	beforSort();
	int gap = high-low+1;
	while (gap>1)
	{
		gap = gap/3+1;
		for(int i = low + gap; i <= high; ++i)  
		{  
			int temp = a[i];    //暂存关键数据
			int j = i;  
			countSortCmp++;
			if (Up)
			{
				while(j-gap >= low && temp < a[j-gap])  
				{  
					a[j] = a[j-gap];   //后移
					j = j-gap;     //前置索引
					countSortCmp++;
					countSortMove++;
				}
			}else
			{
				while(j-gap >= low && temp > a[j-gap])  
				{  
					a[j] = a[j-gap];   //后移
					j = j-gap;     //前置索引
					countSortCmp++;
					countSortMove++;
				}
			}
			a[j] = temp;   
			countSortMove=countSortMove+2;
		}  
	}
}  

//随机快速排序划界函数
int stepRandQuickSort=1;
template <typename DataType>    
void AllSort<DataType>::RandQuickSort(vector<DataType> &a, int low, int high, bool Up)
{
	int pivotKey=0;
	if ( stepRandQuickSort ==1)
	{
		beforSort();
		stepRandQuickSort=0;
	}
	if (low < high)
	{
		pivotKey=RandPartition(a,low,high,Up);
		RandQuickSort(a,low,pivotKey-1,Up);
		RandQuickSort(a,pivotKey+1,high,Up);
	}
}

//随机快速排序的中点函数
template <typename DataType>    
int AllSort<DataType>::RandPartition(vector<DataType> &a, int low, int high, bool Up)
{
	int randPivotKey=rand()%(high-low+1)+low;
	this->swap(&a[randPivotKey],&a[high]);
	countSortMove=countSortMove+3;
	return Partition(a,low,high,Up);
}

int stepthrWayQuickSort=1;
template <typename DataType>    
void AllSort<DataType>::thrWayQuickSort(vector<DataType> &a, int low, int high, bool Up)
{
	if (stepthrWayQuickSort ==1)
	{
		beforSort();
		stepthrWayQuickSort=0;
	}
	int pivotKey=0;
	if (low < high)
	{
		pivotKey=thrWayPartition(a,low,high,Up);
		thrWayQuickSort(a,low,pivotKey-1,Up);
		thrWayQuickSort(a,pivotKey+1,high,Up);
	}
}
//快速排序的中点函数
template <typename DataType>    
int AllSort<DataType>::thrWayPartition(vector<DataType> &a, int low, int high, bool Up)
{
	int PivotKey1=rand()%(high-low+1)+low;
	int PivotKey2=rand()%(high-low+1)+low;
	int PivotKey3=rand()%(high-low+1)+low;

	int midkey=PivotKey1;
	if (PivotKey1 <= PivotKey2 && PivotKey2 <= PivotKey3 )
	{
		midkey=PivotKey2;
		countSortCmp=countSortCmp+2;
	}else if( PivotKey2 <= PivotKey1 && PivotKey1 <= PivotKey3 )
	{
		midkey=PivotKey1;
		countSortCmp=countSortCmp+2;
	}else
	{
		midkey=PivotKey3;
	}

	this->swap(&a[midkey],&a[high]);
	countSortMove=countSortMove+3;
	return Partition(a,low,high,Up);
}

//快速排序
int stepQuickSort=1;
template <typename DataType>    
void AllSort<DataType>::QuickSort(vector<DataType> &a, int low, int high, bool Up)
{
	if (stepQuickSort ==1)
	{
		beforSort();
		stepQuickSort=0;
	}
	int mid=0;
	if (low < high)
	{
		mid=Partition(a,low,high,Up);
		QuickSort(a,low,mid-1,Up);
		QuickSort(a,mid+1,high,Up);
	}
}

//快速排序的划界函数
template <typename DataType>    
int AllSort<DataType>::Partition(vector<DataType> &a, int low, int high, bool Up)
{
	int pivotkey=a[high];//选择主元,即基准元素
	int i=low-1;
	if (Up)
	{
		for ( int j = low;j < high;j++)
		{
			countSortCmp++;
			if (a[j] < pivotkey && i != j )
			{
				i++;
				swap(&a[i],&a[j]);
				countSortMove=countSortMove+3;
			}
		}
	}else
	{
		for ( int j = low;j < high;j++)
		{
			countSortCmp++;
			if (a[j] > pivotkey)
			{
				i++;
				swap(&a[i],&a[j]);
				countSortMove=countSortMove+3;
			}
		}
	}

	i++;
	swap(&a[i],&a[high]);
	countSortMove=countSortMove+3;
	return i;
}

int stepMerge=1;
//合并排序法（分治法）
template <typename DataType>    
void AllSort<DataType>::MergeSort(vector<DataType> &a, int low, int high, bool Up)
{
	if (stepMerge==1)
	{
		beforSort();
		stepMerge=0;
	}
	if (low < high)
	{
		int mid=(low+high)/2;
		MergeSort(a,low,mid,Up);
		MergeSort(a,mid+1,high,Up);
		Merge(a,low,mid,high,Up);
	}

}

//分治法的合并函数
template <typename DataType>    
void AllSort<DataType>::Merge(vector<DataType> &a, int low, int mid, int high,bool Up)
{
	int n1=mid -low+1,n2=high-mid;  
	long Max=99999999;
	long Min=-99999999;
	int *L=new int[n1+1];  
	int *R=new int[n2+1];  
	if ( L == NULL || R == NULL )  
	{  
		exit(1);  
	}  
	int i=0;  
	for ( ;i < n1;i++ )  
	{  
		L[i]=a[low+i];  
		countSortMove++;
	}  
	int j=0;  
	for ( ;j < n2;j++ )  
	{  
		R[j]=a[mid+j+1];  
		countSortMove++;
	}  


	i=0;j=0;  
	int k=0;  
	if (Up)
	{
		L[n1]=Max;//哨兵元素位置  
		R[n2]=Max;
		for ( k = low; k <= high ; k++ )  
		{  
			if ( L[i] <= R[j] )  
			{  
				a[k]=L[i];  
				i++;  
				countSortMove++;
			}else  
			{  
				a[k]=R[j];  
				j++;  
				countSortMove++;
			} 
			countSortCmp++;
		}
	}else
	{
		L[n1]=Min;//哨兵元素位置  
		R[n2]=Min;
		for ( k = low; k <= high ; k++ )  
		{  
			if ( L[i] >= R[j] )  
			{  
				a[k]=L[i];  
				i++;  
				countSortMove++;
			}else  
			{  
				a[k]=R[j];  
				j++;  
				countSortMove++;
			} 
			countSortCmp++;
		}
	}

	delete[] L;  
	delete[] R;  
}

//选择排序法
template <typename DataType>    
void AllSort<DataType>::SelectSort(vector<DataType> &a, int low, int high, bool Up)
{
	beforSort();
	DataType min; 
	DataType max;

	for(int i = low ; i <= high; i++)
	{
		//找到最小值及其位置（准备与a[i]调换）
		min = a[i]; 
		max = a[i];
		int index = i;
		for(int j=i+1;j <= high;j++)
		{
			countSortCmp++;
			if (Up)
			{
				if(a[j] < min)
				{ 
					min = a[j]; //当前最小值
					index = j;//当前最小值的位置
					countSortMove++;
				}  
			}else
			{
				if(a[j] > max)
				{ 
					max = a[j]; //当前最大值
					index = j;//当前最大值的位置
					countSortMove++;
				}  
			}
			
		}       

		if (Up)
		{
			swap(&a[i],&a[index]);
			countSortMove=countSortMove+3;
		}else
		{
			swap(&a[i],&a[index]);
			countSortMove=countSortMove+3;
		}
	}       
}

//冒泡排序
template <typename DataType>    
void  AllSort<DataType>::BubbleSort(vector<DataType> &a, int l, int r, bool Up)    
{   
	beforSort();
	bool flag=false;
	for ( int i = l;i < r;i++)  
	{
		flag=false;
		for ( int j = r;j >= i+1;j--)   
		{
			
			countSortCmp++;
			if (Up)
			{
				if (a[j-1]>a[j])  //调换次序  
				{   
					this->swap(&a[j-1],&a[j]);
					countSortMove=countSortMove+3;
					flag=true;
				}  
			}else
			{
				if (a[j-1]<a[j])    
				{   
					this->swap(&a[j-1],&a[j]);
					countSortMove=countSortMove+3;
					flag=true;
				}  
			}
		}
		if (!flag)
		{
			break;
		}
	}
			 
}  


//插入排序
template <typename DataType>    
void  AllSort<DataType>::InsertSort(vector<DataType> &a, int l, int r, bool Up)    
{   
	beforSort();
	DataType key;
	if (Up)   
	{   
		for ( int i = l+1 ; i <= r;i++ )
		{
			key=a[i];
			int j=i-1;
			countSortCmp++;
			while ( j >= l && a[j] > key )
			{
				a[j+1]=a[j];
				j--;
				countSortMove++;
				countSortCmp++;
			}
			a[j+1]=key;
			countSortMove=countSortMove+2;
		}
	}   
	else   
	{
		for ( int i = l+1 ; i <= r;i++ )
		{
			key=a[i];
			int j=i-1;
			countSortCmp++;
			while (j >= l && a[j] < key)
			{
				a[j+1]=a[j];
				j--;
				countSortMove++;
				countSortCmp++;
			}
			a[j+1]=key;
			countSortMove=countSortMove+2;
		}
	}
}


template <typename DataType>    
int  AllSort<DataType>::Left( int i)    
{   
	
	return 2*i+1;
}

template <typename DataType>    
int  AllSort<DataType>::Right( int i)    
{   
	return 2*i+2;
}
   
//保持堆的性质
template <typename DataType>    
void  AllSort<DataType>::KeepMaxHeap(vector<DataType> &a, int i,int heapsize,bool Up)  //使a[i]这个元素下降（如果不满足最大根要求的话）  
{   
	int l=Left(i);
	int r=Right(i);
	int largest=0;
	int min=0;
	if (Up)
	{
		if (l<= heapsize && a[l]>a[i])//与左子比
		{
			largest=l;
		}
		else
		{
			largest=i;
		}

		if (r<= heapsize && a[r]>a[largest])//将较大者与右子比
		{
			largest=r;
		}
	}else
	{
		if (l<= heapsize && a[l]<a[i])//与左子比
		{
			min=l;
		}
		else
		{
			min=i;
		}

		if (r<= heapsize && a[r]<a[min])//将较大者与右子比
		{
			min=r;
		}
	}
	
	countSortCmp=countSortCmp+2;
	if (Up)
	{
		if (largest!=i)
		{
			swap(&a[i],&a[largest]);
			countSortMove=countSortMove+3;
			KeepMaxHeap(a,largest,heapsize,Up);
		}
	}else
	{
		if (min!=i)
		{
			swap(&a[i],&a[min]);
			countSortMove=countSortMove+3;
			KeepMaxHeap(a,min,heapsize,Up);
		}
	}
	
}

//创建堆,将数组调整为最大堆
template <typename DataType>    
void  AllSort<DataType>::BuildMaxHeap(vector<DataType> &a,bool Up)    
{   
	int heapsize=a.size()-1;
	for (int i=heapsize/2 ; i>=0 ;i-- )
	{
		KeepMaxHeap(a,i,heapsize,Up);//heapsize/2+1到a.size-1的整数都是树叶，所以只需对0到heapsize/2作处理
	}
}

//堆排序
template <typename DataType>    
void  AllSort<DataType>::HeapSort(vector<DataType> &a,bool Up)    
{   
	beforSort();
	BuildMaxHeap(a,Up);//使数组成为最大堆
	int heapsize=a.size()-1;
	for (int i=a.size()-1;i>0;i--)
	{
		swap(&a[0],&a[i]);
		countSortMove=countSortMove+3;
		heapsize--;
		KeepMaxHeap(a,0,heapsize,Up);//保持堆的性质
	}
}


//计数排序
template <typename DataType>   
void AllSort<DataType>::CountSort(vector<DataType> &a,int arrType,int len,bool Up)
{
	int nLen=len;
	int k=0;
	if (arrType==1)
	{
		k=nLen;
	}else
	{
		k=countNum;
	}

	countSortCmp=0;
	DataType* Cout = new DataType[nLen];    //申请空间,用于计数
	//初始化记数为0
	for (int i = 0; i < k; ++i)
	{
		Cout[i] = 0;
	}
	//统计元素出现次数计数。即数组元素a[i]的出现次数,将其结果存放在Cout[a[i]]中。
	for (int i = 0; i < nLen; ++i)
	{
		++Cout[a[i]];        
	}

	//统计小于等于当前位置i的元素个数
	for (int i = 1; i < nLen; ++i)
	{
		Cout[i] += Cout[i - 1];    
	}

	DataType* Sort =new DataType[nLen];    //申请空间，用于存放排序结果

	for (int i = 0; i < nLen; ++i)
	{
		//把数据放在指定位置。因为pCout[pData[i]]的值就是不比他大数据的个数。
		//为什么要先减一，因为pCout[pData[i]]保存的是不比他大数据的个数中包括了
		//他自己，我的下标是从零开始的!所以要先减一。
		--Cout[a[i]];    //因为有相同数据的可能，所以要把该位置数据个数减一。
		Sort[Cout[a[i]]] = a[i];        

	}

	//排序结束，复制到原来数组中。
	if (Up==true)
	{
		for (int i = 0; i < nLen; ++i)
		{
			a[i] = Sort[i];
		}
	}else
	{
		for (int i = 0; i < nLen; ++i)
		{
			a[i] = Sort[nLen-i-1];
		}
	}

	//释放申请的空间。
	delete[] Cout;
	Cout=NULL;
	delete[] Sort;
	Sort=NULL;
}

3，主测试代码：

// ConsoleAppAllSort.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "iostream"  
#include <vector>  
#include <windows.h> 
#include "AllSort.h"
#include "stdio.h"
#include<algorithm>
#include<functional>
using namespace std;

LARGE_INTEGER freq;  
LARGE_INTEGER startTime, stopTime;  
double time;  

void help(int len,bool Up,int IsRand,int arrType);
void initArr();
int _tmain(int argc, _TCHAR* argv[])   
{  
	system("color 0A");
	AllSort<int> sort;//定义排序类对象
	vector<int> arr;       //定义并初始化一个容器,进行数组操作
	int len=10;    //控制数组长度
	char ans='y';
	do 
	{
		cout<<"请输入数组初始化类型及元素个数：（1为元素完全不重复，2为有大量重复值）"<<endl;
		int arrType=1;//1为完全不重复，2为大量重复值
		cin>>arrType>>len;
		sort.InitArr(arr,len,arrType);

		//各大开关
		cout<<"请输入排序类型：0为降序，1为升序"<<endl;
		bool upflag=false;//控制所有排序的升排或者降排的开关
		cin>>upflag;
		cout<<"请输入数组的随机类型：1为纯随机，2为升序，3为降序,4为小随机"<<endl;
		int isRand=1;//1为纯随机，2为升序，3为降序,4为小随机
		cin>>isRand;
		cout<<"是否打印排序结果：0为否，1为是"<<endl;
		bool isPrint=false;//是否print
		cin>>isPrint;
		bool isMove=true;
		help(len,upflag,isRand,arrType);

		cout<<"/**************************改进冒泡法***************************/"<<endl;
		sort.randArray(arr,len,isRand);
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime);  
		sort.BubbleSort(arr,0,arr.size()-1,upflag);
		QueryPerformanceCounter(&stopTime);  
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/*******************std::sort()(注:无法统计次数)******************/"<<endl;
		sort.beforSort();
		sort.randArray(arr,len,isRand);
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime);  
		if (upflag)
		{
			std::sort(arr.begin(),arr.end(),std::less<int>());
		}else
		{
			std::sort(arr.begin(),arr.end(),std::greater<int>());
		}
		
		QueryPerformanceCounter(&stopTime);  
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/**************************插入法***************************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime);  
		sort.InsertSort(arr,0,arr.size()-1,upflag);
		QueryPerformanceCounter(&stopTime);  
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/**************************分治法***************************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime); 
		sort.MergeSort(arr,0,arr.size()-1,upflag);
		QueryPerformanceCounter(&stopTime); 
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/********************快排法(随机划界元)**********************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime); 
		sort.RandQuickSort(arr,0,arr.size()-1,upflag);
		QueryPerformanceCounter(&stopTime); 
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/********************快排法(三数取中划界元)*******************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime); 
		sort.thrWayQuickSort(arr,0,arr.size()-1,upflag);
		QueryPerformanceCounter(&stopTime); 
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/********************快排法(尾端划界元)*************************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime); 
		sort.QuickSort(arr,0,arr.size()-1,upflag);
		QueryPerformanceCounter(&stopTime); 
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/*****************************选择法****************************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime); 
		sort.SelectSort(arr,0,arr.size()-1,upflag);
		QueryPerformanceCounter(&stopTime); 
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/******************************希尔法***************************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime); 
		sort.ShellSort(arr,0,arr.size()-1,upflag);
		QueryPerformanceCounter(&stopTime); 
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"/******************************堆排序法***************************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime); 
		sort.HeapSort(arr,upflag);
		QueryPerformanceCounter(&stopTime); 
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;



		cout<<"/******************************计数序法***************************/"<<endl;
		sort.randArray(arr,len,isRand);//打乱数组
		sort.printArray(arr,isPrint);
		QueryPerformanceCounter(&startTime); 
		sort.CountSort(arr,arrType,len,upflag);
		QueryPerformanceCounter(&stopTime); 
		sort.printArray(arr,isPrint);
		time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
		cout<<"消耗时间"<<time<<"毫秒   ";
		cout<<"移动次数："<<sort.getSortCount(isMove)<<"   比较次数"<<sort.getSortCount(!isMove)<<endl;

		cout<<"是否继续（y/n）？"<<endl;
		cin>>ans;
		arr.clear();
	} while (ans=='y');
	
	system("pause");
	return 0;  
}  

void help(int len,bool Up,int IsRand,int arrType)
{
	cout<<"/***********************综上所述******************************"<<endl;
	cout<<"当前数组元素个数为："<<len<<endl;
	cout<<"原始数组的元素特点："<<endl;
	if (arrType==1)
	{
		cout<<"   1）无重复值"<<endl;
		cout<<"   2）值分布：0-"<<len-1<<endl;
	}else if(arrType==2)
	{
		cout<<"   1）大量重复值"<<endl;
		cout<<"   2）非重复值的分布：0-5"<<endl;
	}
	
	if (IsRand == 1)
	{
		cout<<"   3）随机分布"<<endl;
	}else if(IsRand ==2)
	{
		cout<<"   3) 有序：升序"<<endl;
	}else if(IsRand ==3)
	{
		cout<<"   3) 有序：降序"<<endl;
	}
	else if(IsRand ==4)
	{
		cerr<<"   3) 小随机(总体上呈有序趋势)"<<endl;
	}else
	{
		cerr<<"IsRand参数错误!"<<endl;
	}

	if (Up)
	{
		cout<<"各排序即将执行:升序"<<endl;
	}else
	{
		cout<<"各排序即将执行:降序"<<endl;
	}

	QueryPerformanceFrequency(&freq);  
	QueryPerformanceCounter(&startTime);  
	Sleep(500);  
	QueryPerformanceCounter(&stopTime);  
	time = 1e3*(stopTime.QuadPart-startTime.QuadPart)/freq.QuadPart;  
	cout<<"你电脑的频率为："<<freq.QuadPart<<endl;
	cout<<"你的电脑执行Sleep(500)消耗时间为："<<time<<"毫秒"<<endl;
}

三，测试结果

（篇幅有限，仅展示部分结果）

四，总结：

1、冒泡排序
优点：稳定；思想易理解，编写简单
缺点：慢，每次只能移动相邻两个数据。

2、选择排序
优点：编写简单；移动数据的次数已知（n-1次）；
缺点：比较次数多。

3、插入排序
优点：稳定，思想简单，编写简单。
缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。

4、希尔排序
优点：快，数据移动少；
缺点：不稳定，gap的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取，并且无法对链表排序。

5、快速排序
快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。
优点：极快，数据移动少；
缺点：不稳定。

6、归并排序
归并排序是多次将两个或两个以上的有序表合并成一个新的有序表。最简单的归并是直接将两个有序的子表合并成一个有序的表。
归并排序是稳定的排序.即相等的元素的顺序不会改变.如输入记录 1(1) 3(2) 2(3) 2(4) 5(5) (括号中是记录的关键字)时输出的 1(1) 2(3) 2(4) 3(2) 5(5) 中的2 和 2 是按输入的顺序.这对要排序数据包含多个信息而要按其中的某一个信息排序,要求其它信息尽量按输入的顺序排列时很重要.这也是它比快速排序优势的地方.
归并排序：归并排序是一种非就地排序，将需要与待排序序列一样多的辅助空间。在使用它对两个己有序的序列归并，将有无比的优势。其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlog2n)。对数据的有序性不敏感。若数据节点数据量大，那将不适合。但可改造成索引操作，效果将非常出色。

7、堆排序：

由于它在直接选择排序的基础上利用了比较结果形成。效率提高很大。它完成排序的总比较次数为O(nlog2n)。它是对数据的有序性不敏感的一种算法。但堆排序将需要做两个步骤：
一是建堆，二是交换数值（或者输出堆），三是排序（调整堆）。
所以一般在小规模的序列中不合适，但对于较大的序列，将表现出优越的性能。

8、计数排序：

对于数组元素集中在小范围内的整数数组排序特别快，并且也是稳定排序，但是这种排序算法缺点特别大。

参考资源：

【1】《算法导论》
【2】《维基百科》
【3】《百度文库》
【4】http://www.oschina.net/question/1397765_159365
【5】http://www.cnblogs.com/biyeymyhjob/archive/2012/07/17/2591457.html
【6】http://blog.csdn.net/xiazdong/article/details/8462393
【7】http://baike.baidu.com/view/297739.htm
【8】http://www.cnblogs.com/kaituorensheng/archive/2013/02/23/2923877.html
【9】http://blog.csdn.net/hguisu/article/details/7776068
【10】http://blog.csdn.net/speedme/article/details/23021467

注：

本文部分文字参考并整理自网络，代码参考并改编自算法导论.

如果侵犯了您的版权，请联系本人tangyibiao520@163.com，本人将及时编辑掉！