内部排序Word文档格式.docx
《内部排序Word文档格式.docx》由会员分享，可在线阅读，更多相关《内部排序Word文档格式.docx（19页珍藏版）》请在冰豆网上搜索。
usingnamespacestd;
#defineNUM100
#defineM30000
voidZhijiepaixu（int*pData,intn）//形参为输入的数据及输入数据的个数
{
//直接插入排序
intiTemp;
boolflag=1;
intiPos;
for（inti=1;
i<
n;
i++）
{
iTemp=pData[i];
iPos=i-1;
while（（iPos>
=0）&
&
（iTemp<
pData[iPos]））
if（flag）
flag=0;
}
pData[iPos+1]=pData[iPos];
//将值大的数放在后面
iPos--;
flag=1;
pData[iPos+1]=iTemp;
//因为iPos执行了一次--所以将第i个值赋给iPos+1
}
voidXuanzepaixu（int*pData,intn）
//选择排序
for（inti=0;
n-1;
iPos=i;
for（intj=i+1;
j<
j++）
if（pData[j]<
iTemp）
//如果第j个数小于第i个数则将第i个数赋值给此趟比较的最小值上
iTemp=pData[j];
iPos=j;
pData[iPos]=pData[i];
pData[i]=iTemp;
voidQipaopaixu（int*pData,intn）//形参为输入的数据及输入数据的个数
//起泡排序
for（intj=n-1;
j>
=i;
j--）
pData[j-1]）
{
flag=0;
}
iTemp=pData[j-1];
pData[j-1]=pData[j];
pData[j]=iTemp;
voidShellpaixu（int*pData,intn）
//希尔排序
intstep[6]={24,15,9,5,3,1};
inti,iTemp;
intk,w;
for（i=0;
6;
k=step[i];
for（intj=k;
w=j-k;
//求上step个元素的下标
while（（iTemp<
pData[w]）&
（w>
（w<
=n））
pData[w+k]=pData[w];
w=w-k;
pData[w+k]=iTemp;
voidrun（int*pData,intleft,intright）
inti,j;
intmiddle,iTemp;
i=left;
j=right;
middle=pData[（left+right）/2];
//求中间值
do
while（（pData[i]<
middle）&
（i<
right））//从左扫描大于中值的数
{
i++;
if（flag）
while（（pData[j]>
（j>
left））//从右扫描大于中值的数
j--;
if（i<
=j）//找到了一对值
{//交换
pData[i]=pData[j];
i++;
j--;
}while（i<
=j）;
//如果两边扫描的下标交错，就停止（完成一次）
//当左边部分有值（left<
j），递归左半边
if（left<
j）
run（pData,left,j）;
//当右边部分有值（right>
i），递归右半边
if（right>
i）
run（pData,i,right）;
voidKuaisupaixu（int*pData,intn）
//快速排序
run（pData,0,n-1）;
voidZhijiaohuan（int&
a,int&
b）
//进行值的交换
inttmp;
tmp=a;
a=b;
b=tmp;
voidheap_adjust（intarray[],inti,intn）
//实现子结点值大于父结点，且左子树值小于右子树
intrc=array[i];
for（intj=2*i;
j<
=n;
j*=2）
if（j<
n&
array[j]<
array[j+1]）
j++;
if（rc>
=array[j]）
break;
array[i]=array[j];
i=j;
array[i]=rc;
voidDuipaixu（int*pData,intn）
inti;
for（i=n/2;
i>
0;
i--）
heap_adjust（pData,i,n）;
for（i=n;
1;
Zhijiaohuan（pData[1],pData[i]）;
//弹出最大值，重新对i-1个元素建堆
heap_adjust（pData,1,i-1）;
intSort（inta[],intmerge[],intlow,inthigh）//把a中的值排序到merge中
intb[M];
//这是个temp局部值，它能保存两个半区
intmid=（high+low）/2;
inti=low,j=mid+1,k=low;
if（low>
=high）//递归出口
if（low==high）merge[low]=a[low];
return0;
Sort（a,b,low,mid）;
//分成两个子数组，进行排序
Sort（a,b,mid+1,high）;
while（（i<
=mid）&
（j<
=high））//进行合并操作
if（b[i]<
=b[j]）
merge[k++]=b[i++];
}
else
merge[k++]=b[j++];
while（i<
=mid）
merge[k++]=b[i++];
while（j<
=high）
merge[k++]=b[j++];
return0;
intRADIX（intarray[],intp）
intN[10],k=0;
inti=0,n,a[10][10000],j,m=0;
10;
N[i]=0;
p;
n=array[i]/（（int）pow（10,（double）k））%10;
a[n][N[n]++]=array[i];
for（j=0;
N[i];
array[m++]=a[i][j];
intrandom（intA[]）
M;
A[i]=rand（）%30001;
voidShiJian（）
intA[M],B[M+1],C[M],D[M],i,j;
time_tstart1,end1,start2,end2,start3,end3,start4,end4;
time_tstart5,end5,start6,end6,start7,end7,start8,end8;
random（C）;
A[i]=C[i];
start1=time（NULL）;
Zhijiepaixu（A,M）;
end1=time（NULL）;
cout<
<
"
直接排序的运行时间为:
end1-start1<
秒!
endl;
start2=time（NULL）;
Xuanzepaixu（A,M）;
end2=time（NULL）;
选择排序的运行时间为:
end2-start2<
start3=time（NULL）;
Qipaopaixu（A,M）;
end3=time（NULL）;
冒泡排序的运行时间为:
end3-start3<
start4=time（NULL）;
Shellpaixu（A,M）;
end4=time（NULL）;
希尔排序的运行时间为:
end4-start4<
start5=time（NULL）;
Kuaisupaixu（A,M）;
end5=time（NULL）;
快速排序的运行时间为:
end5-start5<
for（i=0,j=1;
M,j<
=M;
i++,j++）
B[j]=C[i];
start6=time（NULL）;
Duipaixu（B,M）;
end6=time（NULL）;
堆排序的运行时间为:
end6-start6<
/*for（i=0;
start7=time（NULL）;
Sort（A,D,0,M-1）;
end7=time（NULL）;
归并排序的运行时间为:
end7-start7<
*/
start8=time（NULL）;
5;
RADIX（A,M）;
end8=time（NULL）;
基数排序的运行时间为:
end8-start8<
voidmenu1（）
printf（"
-----------------------------------\n"
）;
排序类型：
\n"
1.直接插入排序\n"
2.直接选择排序\n"
3.起泡排序\n"
4.Shell排序\n"
5.快速快序\n"
6.堆排序\n"
7.归并排序\n"
8.基数排序\n"
0.结束排序\n"
voidmenu（）
-----------------------------------"
1.基本的排序类型"
2.计算各种排序方式的运行时间"
0.结束程序"
intmain（）
intpdata[NUM],data[NUM],pdata1[NUM],merge[NUM];
inti,n,op,j,m,p;
charE[6];
menu（）;
输入选择:
;
cin>
>
m;
switch（m）
case1:
输入需排序数据的个数:
scanf（"
%d"
&
n）;
输入"
n<
个数据：
data[i]）;
n,j<
pdata[i]=data[i];
pdata1[j]=data[i];
menu1（）;
op）;
switch（op）
case1:
Zhijiepaixu（pdata,n）;
直接排序的结果：
for（i=0;
pdata[i]<
"
\n"
case2:
Xuanzepaixu（pdata,n）;
选择排序的结果：
case3:
Qipaopaixu（pdata,n）;
冒泡排序的结果：
case4:
Shellpaixu（pdata,n）;
希尔排序的结果：
case5:
Kuaisupaixu（pdata,n）;
快速排序的结果：
case6:
Duipaixu（pdata1,n）;
堆排序的结果：
for（i=1;
pdata1[i]<
case7:
Sort（pdata,merge,0,n-1）;
归并排序的结果:
%d"
merge[i]）;
case8:
sprintf（E,"
pdata[0]）;
p=strlen（E）;
RADIX（pdata,n）;
基数排序的结果:
case0:
排序结束！
！
default:
输入错误！
}while（op!
=0）;
case2:
ShiJian（）;
程序结束！
}while（m!
升级会员 