排序算法实例精粹（windows c++ 验证）

//sort.hpp文件

/*
1.
插入排序

最好情况：元素数组本身是排好的；比较次数n-1;元素移动次数0;

最坏情况：元素数组是倒序的；比较次数KCN=n(n-1)/2 =n*2/2;元素移动次数 （n+4）(n-1)/2=n*n/2;

所以直接插入排序时间复杂度为O(n*n);

直接插入排序是一种稳定排序算法;
*/

template<class T>
void insertSort(T dataList[], const int left, const int right)
{
	T tmp;
	int i=0,j=0;

	for(i= left+1; i<=right; i++)
	{
		if(dataList[i] < dataList[i-1])
		{
			tmp = dataList[i];
			j= i-1;

			do 
			{
				dataList[j+1] = dataList[j];
				j--;
			}while (j>=left && tmp < dataList[j]);

			dataList[j+1] = tmp;

		}
	}
}


/*
2.
折半插入排序

折半插入排序搜索速度比直接插入排序快。
元素比较次数与待排序元素序列的初始排序无关，仅依赖元素个数。
元素比较次数：n*log2n-n+1
元素移动次数 （n+4）(n-1)/2=n*n/2（和直接插入排序算法一样）;
数据量较大时，比直接插入排序有优势
折半插入排序是稳定排序算法
*/
template<class T>
void binaryInsertSort(T dataList[], const int left, const int right)
{
	for (int i=left+1; i<= right; i++)
	{
		
		if (dataList[i]<dataList[i-1])
		{
			T tmp = dataList[i];

			int nLow = left;
			int nHigh = i;

			while(nLow < nHigh)
			{
				
				int nMid = (nHigh-nLow)/2+nLow;

				if (tmp <= dataList[nMid])
				{
					nHigh = nMid-1;
				}
				else
				{
					nLow = nMid+1;
				}
			}

			for (int k = i; k>nLow; k--)
			{
				dataList[k] = dataList[k-1];
			}

			dataList[nLow] = tmp;
			
		}
	}
}

/*
3.
希尔排序算法(又称为缩小增量排序 diminishing-incrementsort) 1959年希尔提出
算法思想：设带排序元素序列有n个元素，首先取一个整数gap(gap<n),作为间隔，将全部元素分为gap个子序列，
所有距离为gap的元素放在同一个子序列中，在每个子序列中分别进行直接插入排序。
然后缩小gap,例如gap=gap/2,重复上述的子序列划分和排序工作，直到gap==1，将所有元素放在同一个序列中排序为止。
元素移动次数：n的1.25次方-1.6*n的1.25次方

由于即使对于规模较大的序列（n<=1000）,希尔排序都具有很高的效率，很多应用程序都选择希尔排序。
希尔排序是一种不稳定排序算法
*/

template<class T>
void shellSort(T dataList[], const int left, const int right)
{
	int i=0;
	int j=0;
	int gap = right - left + 1;//增量的初始化值

	T tmp = 0;
	do 
	{

		gap = gap / 3 + 1;//求下一增量值

		for (i=left+gap; i<=right; i++)
		{

			if (dataList[i] < dataList[i-gap])
			{

				tmp = dataList[i];
				j = i-gap;

				do 
				{

					dataList[j+gap] = dataList[j];
					
					j = j - gap;

				} while (j > left && tmp < dataList[j]);
				
				dataList[j+gap] = tmp;

			}

		}

	} while (gap > 1);
}

/*
4.
快速排序算法

快速排序算法是C.R.A.Hoare 于1992年提出的一种划分交换的方法，它采用分治法(divide-and-conquer)进行排序。基本思想就是任取待排序元素序列中的某个元素
作为基准，将大于这个数的放在右边，将小于这个数的放在左边，。然后分别对这两个子序列重复实施上述方法，直到所有元素都排在相应的位置为止。

*/


template<class T>
int Partion(T dataList[], const int left, const int right)
{
	T  nBaseData = dataList[left];

	int nPosCurBase = left;

	for (int i=left+1; i<=right; i++)
	{

		if ( dataList[i] < nBaseData )
		{

			nPosCurBase++;
			if(i != nPosCurBase) 
			{

				T tmp = dataList[nPosCurBase];
				dataList[nPosCurBase] = dataList[i];
				dataList[i] = tmp;
			}
		}
	}

	dataList[left] = dataList[nPosCurBase];
	dataList[nPosCurBase] = nBaseData;

	return nPosCurBase;

}

template<class T>
void	quickSort(T dataList[], const int left, const int right)
{

	if (left >= right)
	{
		return;
	}

	int nPosCurBase = Partion(dataList, left, right);

	quickSort(dataList, left, nPosCurBase-1);
	quickSort(dataList, nPosCurBase+1, right);

}


/*
5.
选择排序
*/

template<class T>
void	selectSort(T datalist[], const int nLeft, const int nRight)
{
	for (int i=nLeft; i<nRight; i++)
	{
		int minIndex = i;

		for (int j=i; j<=nRight; j++)
		{
			if (datalist[j] < datalist[minIndex])
			{
				minIndex = j;
			}
		}

		if (minIndex != i)
		{
			T tmp = datalist[i];
			datalist[i] = datalist[minIndex];
			datalist[minIndex] = tmp;
		}

	}
}

/*
6.
归并排序
*/

template<class T>
void merge(T datalist[], int nLeft, int nMid, int nRight)
{
	int nLenLeft = nMid - nLeft + 1;
	int nLenRight = nRight - nMid;

	T *pLeft = new T[nLenLeft];
	T *pRight = new T[nLenRight];

	int i=0;
	int j=0;
	for ( i=0; i<nLenLeft; i++)
	{
		pLeft[i] = datalist[i+nLeft];
	}

	for ( j=0; j<nLenRight; j++)
	{
		pRight[j] = datalist[nMid+j+1];
	}

	i=0;
	j=0;
	int k = nLeft;
	for (k=nLeft; k<nRight; k++)
	{
		if (!(i<nLenLeft && j <nLenRight))
		{
			break;
		}

		if (pLeft[i]<pRight[j])
		{
			datalist[k] = pLeft[i];
			i++;
		}
		else
		{
			datalist[k] = pRight[j];
			j++;
		}
	}

	while(i<nLenLeft)
	{
		datalist[k++] = pLeft[i];
		i++;
	}

	while(j<nLenRight)
	{
		datalist[k++] = pRight[j];
		j++;
	}

	if (pLeft)
	{
		delete []pLeft;
		pLeft = NULL;
	}

	if (pRight)
	{
		delete [] pRight;
		pRight = NULL;
	}
}

template<class T>
void mergeSort(T datalist[], int nLeft, int nRight)
{
	if (nLeft>=nRight)
	{
		return;
	}

	int nMid = (nRight+nLeft)/2;
	mergeSort(datalist, nLeft, nMid);
	mergeSort(datalist, nMid+1, nRight);

	merge(datalist, nLeft, nMid, nRight);

}

/*
7.
冒泡排序应该是最垃圾的一种排序算法，而选择排序是冒泡排序的一种升级
2014年2月18日18:16:58
*/
template<class T>
void paopaoSort(T datalist[], int nLeft, int nRight)
{

	for (int i=nLeft; i<nRight; i++)
	{
		for (int j=i+1; j<=nRight; j++)
		{
			if (datalist[j] < datalist[i])
			{
				T tmp = datalist[i];
				datalist[i] = datalist[j];
				datalist[j] = tmp;
			}
		}
	}

}
/*
8.
分配排序之桶式排序*/
/*
9.
分配排序之基数排序*/

/*内部排序算法的分析*/
//sort.hpp 完

 

//main.cpp -------------------------------------------------------------------------------------------------------------------


#include "sort.hpp"


template<class T>
void show(T *p, int nlen)
{
	for (int i=0; i<nlen; i++)
	{
		std::cout<<p[i]<<"-";
	}
	std::cout<<std::endl;

}

int a[]={2,3,4,5,4,3,3,3,4,5,6,5,3,56,7,7,5,3};
int b[]={2,3,4,5,4,3,3,3,4,5,6,5,3,56,7,7,5,3};
int c[]={2,3,4,5,4,3,3,3,4,5,6,5,3,56,7,7,5,3};
int d[]={2,3,4,5,4,3,3,3,4,5,6,5,3,56,7,7,5,3};
int e[]={2,3,4,5,4,3,3,3,4,5,6,5,3,56,7,7,5,3};
int f[]={2,3,4,5,4,3,3,3,4,5,6,5,3,56,7,7,5,3};
int g[]={2,3,4,5,4,3,3,3,4,5,6,5,3,56,7,7,5,3};
int _tmain(int argc, _TCHAR* argv[])
{

	int nLen = sizeof(a)/sizeof(int);

	insertSort(a, 0, nLen-1);
	show<int>(a, nLen);

	binaryInsertSort<int>(b, 0, nLen-1);
	show<int>(b, nLen);

	shellSort<int>(c, 0, nLen-1);
	show<int>(c, nLen);

	quickSort<int>(d, 0, nLen-1);
	show<int>(d, nLen);

	selectSort<int>(e, 0, nLen-1);
	show<int>(e, nLen);

	mergeSort<int>(f, 0, nLen-1);
	show<int>(f, nLen);

	paopaoSort<int>(g, 0, nLen-1);
	show<int>(g, nLen);
	return 0;
}
//main.cpp完

输出结果：

2-3-3-3-3-3-3-4-4-4-5-5-5-5-6-7-7-56-
3-3-3-2-3-4-3-4-5-3-5-4-5-5-7-6-7-56-
2-3-3-3-3-3-3-4-4-4-5-5-5-5-6-7-7-56-
2-3-3-3-3-3-3-4-4-4-5-5-5-5-6-7-7-56-
2-3-3-3-3-3-3-4-4-4-5-5-5-5-6-7-7-56-
2-3-3-3-3-3-3-4-4-4-5-5-5-5-6-7-7-56-
2-3-3-3-3-3-3-4-4-4-5-5-5-5-6-7-7-56-
请按任意键继续. . .