b[i]=a[i]:
LARGE,INTEGERm_liPerfFreq二(0);
QueryPerformanceFrequency(&mIiPerfFreq);
LARGE.INTEGERm_liPerfStart={01:
QueryPerformanceCounter(&m一IiPerfStart);
InsertSort(b.p);
LARGE_INTEGERIiPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
doubletime=liPerfNow.QuadPart-m_liPerfStart.QuadPart;time/=m_IiPerfFreq.QuadPart:
if(p!
=6)
(
Disp⑹;getchar();
)
printfC'\n用直接插入排序法用的时间为%f秒;".time);
FILE*fp;
fp=fopenC,直接插入排序.txt”,"w”);
for(i=0:
ifprintf(fp,n%db[i]);
fclose(fp);
return(time);
}
doubleTSeIectSort(inta[],intp)//计算选择排序用时
{
inti:
intb[N];
for(i=0;ib[i]=a[i];
LARGE」NTEGERm_liPerfFreq={0};
QueryPerformanceFrequency(&m.IiPerfFreq);
LARGE,INTEGERm_liPerfStart={01:
QueryPerformanceCounter(&m_liPerfStart);
SeiectSort(b,p);
if(p!
=6)
Disp(b);
getchar():
)
LARGEINTEGERIiPerfNow=(01;
QueryPerformanceCounter(&liPerfNow);
doubletime=liPerfNow.QuadPart-m_liPerfStart.QuadPart;time/=m_IiPerfFreq.QuadPart:
printf(M\n用直接选择排序法用的时间为%f秒;".time);
FILE*fp;
fp=fopen(M直接选择排序.txt”,"w");
for(i=0;ifprintf(fp,"%d",b[i]);
fclose(fp);
return(time);
}
doubleTBubbleSort(inta[].intp)//计算冒泡排序算法用时
{
inti:
intb[N];
for(i=0;i〈N;i++)
b[i]=a[i]:
LARGEINTEGERIiPerfFreq二{0};
QueryPerformanceFrequency(&m_IiPerfFreq);
LARGE」NTEGERIiPerfStart二{0):
QueryPerformanceCounter(&mIiPerfStart);BubbleSort(b,p);
LARGEINTEGERliPerfNow二(0);
QueryPerformanceCounter(&liPerfNow):
doubletime=liPerfNow.QuadPart-mIiPerfStart.QuadPart;time/=m_IiPerfFreq.QuadPart;
if(p!
=6)
{
Disp⑹;
getchar():
)
printf(M\n用冒泡排序法用的时间为%f秒;”,time);
FILE*fp;
fp=fopenC'■泡排序.txt","w");
for(i=0;ifprintf(fp,"%db[i]);
fclose(fp);
return(time);
}
doubleTquicksort(inta[],intn.intp)〃计算快速排序算法用时{
inti:
intb[N];
for(i=0;ib[i]=a[i];
LARGE」NTEGERm_liPerfFreq二(0);
QueryPerformanceFrequency(&mIiPerfFreq);
LARGE,INTEGERm_liPerfStart={01;
QueryPerformanceCounter(&m_IiPerfStart);
quicksort(b,N.p);
LARGE_INTEGERIiPerfNow=(0);
QueryPerformanceCounter(&liPerfNow);
doubletime=liPerfNow.QuadPart-m_liPerfStart.QuadPart;time/=m_IiPerfFreq.QuadPart:
if(p!
=6)
(
Disp(b);
getchar():
)
printf(”\n用快速排序法用的时间为新秒;Mime):
FILE*fp;
fp=fopen("快速排序.txt","w");
for(i=0;ifprintf(fp,",b[i]);
fclose(fp);
return仕ime);
}
voidBubIeSort(doublea[])//时间数组的冒泡排序
{
inti,j;
doubletemp;
for(i=1;iC6;i++)
{
for(j=4;j>二i;j—)
if(a[j+1]temp=a[j+1];a[j+1]=a[j];a[j]=temp;
}
I
voidmenu()
{
printfC'*********************************\n\n»)•printf("
(1)显示随机数\n");
printfC
(2)直接插入排序\n-);
printfC(3)直接选择排序\n”);
printfC(4)冒泡排序\n");
printfC(5)快速排序\n");
printfC(6)时间效率比较\n”);
printfC'\n请在上述序号中选择一个井输入:
\n");
printf(,,*********************************\n't);)
voidmainO
{
inti,p.a[N];
srand((int)time(NULL));//随机种子
for(i=0;ia[i]=rand()%50000+1;
while
(1)
(
system("cIs");
menu();
scanf&p);
if(p=0)
(
printfC*谢谢使用!
\n”);
getchar();
break:
1
doubleTIMES[5],TIMES1[5];//时间数组
switch(p)
case1:
Disp(a);
FILE*fp;
fp=fopen(M随机数.txtMfMwH);
for(i=0;igetchar();
printf("\n请按任意键继续!
”);
getchar();
break:
case2:
TlnsertSort(a,p);
printf("\n请按任意键继续!
”):
getchar();
break:
case3:
TSeIectSort(a,p);
printf("\n请按任意键继续!
”):
getchar();
break;
case4:
TBubbleSort(a,p);printf("\nW按任意键继续!
”);getchar();
break:
case5:
Tquicksort(a.N,p);printf(H\n请按任意键继续!
”);getchar();
break;
case6:
systemCcIs");
TlMES1[1]=TIMES[1]=TInsertSort(a,p);TlMES1[2]=TIMES[2]=TSeIectSort(a.p);TIMES1[3]=TIMES[3]=TBubbIeSort(a.p);
TIMES1[4]=TIMES[4]=Tquicksort(a.N,p);getchar();
BubIeSort(TIMES);
printfC"排序这组数据较快的排序法是:
\2);
if仃IMES[1]!
=TIMES[2])
{
if(TIMES[2]==TIMES1[1])printf("直接插入排序:
%f秒!
\n",TIMES[2]);
if(TIMES[2]==TIMES1[2])printf(M直接选择排序%f秒!
\n”,TIMES[2]);
if(TlMES[2]==TIMES1[3])printf("冒泡排序轩秒!
\nH,TIMES[2]);if(TlMES[2]==TIMES1[4])printf("快速排序秒!
\nH.TIMES[2]);
)
)
printf("\nW按任意键继续!
”):
srand((int)time(NULL));
for(i=0;ii++)
{
a[i]=rand0%30000+1;
1
getchar();
break;
default:
Wrong();
printf("\n请按任意键继续!
”);
getchar();
break;
1
)
)
3、运行结果与分析:
通过多次运行程序,均显示快速排序算法最快,时间复杂度最低,通过所学的知识来计算,快速排序平均时间复杂度是0(nlog2n),最好情况0(nlog2n),最坏情况0(n2),相对来说,这次实验符合理论规律。