讲道理,快速排序不是应该比希尔排序更快吗?

但是我写的代码测试出来确实希尔排序比快速排序快得多,这是为什么呢?而且没对快速排序优化之前,两次递归,很容易栈溢出,崩溃

这是为什么呢?上代码:

//希尔排序
template<class T>
void ShellSort(T* pArr ,int nLength)
{
	//设置增量,做插入排序,分组有序,最后全部有序
	int i,j,nIncrement=nLength;
	do 
	{
		//分组
		nIncrement =nIncrement/2;
		for (i =nIncrement;i<nLength;i++)
		{	//当次循环,后面一组中与前面一组一一对应比较,
			if (pArr[i] < pArr[i-nIncrement])
			{
				T temp =pArr[i];
				//有步长的插入排序,使分组与分组对应位置的元素是有序的。
				for (j =i-nIncrement;j>=0&&pArr[j]>temp;j-=nIncrement)
					pArr[j+nIncrement] = pArr[j];
				pArr[j+nIncrement] = temp;
			}
		}
	} while (nIncrement>1);
}

//快速排序
template<class T>
void QSort(T* pArr,int nStart,int nEnd)
{
	while (nStart < nEnd)
	{
		//初始化第一个为枢轴值
		int mid =(nStart+nEnd)/2;
		T nPivotkey, temp ;
		//三数取中值为枢轴值
		if((pArr[nStart]>pArr[mid]&&pArr[nStart]<pArr[nEnd]) || 
			(pArr[nStart]>pArr[nEnd]&&pArr[nStart]<pArr[mid]))
			mid =nStart;
		else if((pArr[nEnd]>pArr[mid]&&pArr[nStart]>pArr[nEnd]) || 
			(pArr[nStart]<pArr[nEnd]&&pArr[mid]>pArr[nEnd]))
			mid =nStart;
			
		//保存枢轴值
		nPivotkey=pArr[mid];
		int nPivot = nStart;
		int nTempEnd=nEnd;
		//一轮交换确定枢轴值位置
		while(nPivot <nTempEnd)
		{
			//小的到前面
			while(nPivot<nTempEnd && !(pArr[nTempEnd]<nPivotkey))
				nTempEnd--;
			temp = pArr[nTempEnd];
			for (int i=nTempEnd-1;i>=nPivot;i--)
				pArr[i+1]=pArr[i];
			pArr[nPivot] = temp;
			//大的到后面
			while(nPivot < nTempEnd && !(pArr[nPivot] > nPivotkey))
				nPivot++;
			temp = pArr[nPivot];
			for (int i=nPivot+1;i<=nTempEnd;i++)
				pArr[i-1]=pArr[i];
			pArr[nTempEnd] = temp;
		}
		//递归调用
		QSort(pArr,nStart,nPivot);
		//尾递归
		nStart =nPivot+1;

	}
}
template<class T>
void QuickSort(T* pArr,int nLength)
{
	QSort(pArr,0,nLength-1);
}
100个简单数据,完全逆序的排序时间

1000个简单数据,完全逆序的排序时间


5000个简单数据,完全逆序的排序时间


10000个简单数据,完全逆序的排序时间


10万个简单数据,完全逆序的排序时间

这样看起来快速排序似乎并不快啊,是不是我哪里写错了??


已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页