课程设计题目排序Word格式.docx
《课程设计题目排序Word格式.docx》由会员分享，可在线阅读，更多相关《课程设计题目排序Word格式.docx（18页珍藏版）》请在冰豆网上搜索。
//快速排序快速排序是对冒泡排序的一种改进
voidquicksortx（Data）;
voidtowmerge（Data&
Data&
int,int,int）;
//二路归并排序算法
voidmergepass（Data&
int）;
//一趟2路归并算法
voidmergesort（Data,Data）;
//2-路归并算法
list（）{}
voiddisplay（Data）;
voidshow（int）;
Datagetdata1（int）;
Datagetdata2（）;
voidplay1（int）;
voidplay2（）;
voidplay3（）;
intlist:
:
remove=0;
compare=0;
Datalist:
getdata1（intlength）
Datadata;
data.length=length;
srand（（int）time（0））;
for（inti=0;
i<
length;
i++）
{
data.dt[i]=random（1000）;
}
pare=0;
data.remove=0;
returndata;
}
getdata2（）
intn=0;
intm;
cout<
<
"
请输入待输入数据的个数：
\n"
;
cin>
>
n;
data.length=n;
cout<
请输入第"
i+1<
个数据：
cin>
m;
data.dt[i]=m;
voidlist:
display（Datadata）
data.length;
data.dt[i]<
"
if（（i+1）%10==0）
cout<
endl;
insertsort（Datadata,inth）//直接插入排序
for（inti=1;
n=data.dt[i];
intj=i-1;
while（j>
=0&
&
data.dt[j]>
n）
{
data.dt[j+1]=data.dt[j];
data.remove++;
j--;
}
data.dt[j+1]=n;
pare+=data.remove+data.length-1;
if（h==1）
比较结果为：
display（data）;
\n其中\n"
直接插入排序--"
比较次数：
pare<
移动次数：
data.remove<
binsertsort（Datadata）//折半插入排序
intj=0;
intlow=0;
inthigh=0;
intmiddle=0;
low=0;
high=i-1;
while（low<
=high）
pare++;
middle=（low+high）/2;
if（data.dt[middle]>
high=middle-1;
else
low=middle+1;
for（j=i-1;
j>
high;
j--）
data.dt[high+1]=n;
//cout<
======================================\n"
折半插入排序--"
//display（data）;
selectsort（Datadata）//直接选择排序
intj=i;
for（intk=j+1;
k<
k++）
if（data.dt[j]>
data.dt[k]）
j=k;
if（j!
=i）
ints=data.dt[i];
data.dt[i]=data.dt[j];
data.dt[j]=s;
直接选择排序--"
//display（data）;
bubblesort（Datadata）//冒泡排序
for（inti=data.length-1;
i>
0;
i--）
for（intj=0;
j<
i;
j++）
{
data.dt[j+1]）
{
n=data.dt[j];
data.dt[j]=data.dt[j+1];
data.dt[j+1]=n;
data.remove++;
}
冒泡排序--"
//display（data）;
quicksort（Data&
data,ints,intt）//快速排序
intn;
inti=s;
intj=t;
if（j>
i）
do{
while（j>
i&
=n）
j--;
pare++;
if（j>
data.dt[i]=data.dt[j];
i++;
=n）
data.dt[j]=data.dt[i];
}while（j>
i）;
data.dt[i]=n;
quicksort（data,s,i-1）;
quicksort（data,j+1,t）;
quicksortx（Datadata）
quicksort（data,0,data.length-1）;
快速排序--"
shellsort（Datadata）//希尔排序
inti=0,j=0,gap=0;
gap=data.length/2;
while（gap>
0）
for（i=gap;
j=i-gap;
=0）
if（data.dt[j]>
data.dt[j+gap]）
{
n=data.dt[j+gap];
data.dt[j+gap]=data.dt[j];
data.dt[j]=n;
j=j-gap;
data.remove++;
}
else
j=-1;
gap=gap/2;
希尔排序--"
}
towmerge（Data&
data1,Data&
data2,ints,intm,intt）
inti,j,k;
i=s;
j=m+1;
k=s;
while（i<
=m&
=t）
compare++;
if（data1.dt[i]<
=data1.dt[j]）
data2.dt[k]=data1.dt[i];
k++;
i++;
else
data2.dt[k]=data1.dt[j];
remove++;
j++;
while（i<
=m）
while（j<
mergepass（Data&
data,Data&
r,intlen）
intp=0;
while（p+2*len-1<
data.length）
towmerge（data,r,p,p+len-1,p+2*len-1）;
p=p+2*len;
if（p+len-1<
data.length-1）
towmerge（data,r,p,p+len-1,data.length-1）;
else
for（inti=p;
r.dt[i]=data.dt[i];
mergesort（Datadata,Datar）//2-路归并算法
intlen;
len=1;
while（len<
mergepass（data,r,len）;
len=len*2;
mergepass（r,data,len）;
二路归并排序--"
compare<
remove<
play1（intq）
Datar;
r.length=0;
r.remove=0;
list:
list:
data=getdata1（q）;
r.length=q;
原始数据为：
display（data）;
/*cout<
其中\n"
*/
insertsort（data,1）;
binsertsort（data）;
selectsort（data）;
bubblesort（data）;
shellsort（data）;
quicksortx（data）;
mergesort（data,r）;
play2（）
data=getdata2（）;
r.length=data.length;
play3（）
Datadata[3];
Datad[3];
Datar[3];
3;
r[i].length=0;
r[i].remove=0;
data[0]=getdata1（10）;
第一组，随机产生十个数：
display（data[0]）;
==================\n"
data[1]=getdata1（50）;
第二组，随机产生五十个数：
display（data[1]）;
data[2]=getdata1（100）;
第三组，随机产生一百个数：
display（data[2]）;
d[0]=insertsort（data[0],0）;
d[1]=insertsort（data[1],0）;
d[2]=insertsort（data[2],0）;
第一组\n"
display（d[0]）;
第二组\n"
display（d[1]）;
第三组\n"
display（d[2]）;
d[0].compare<
d[0].remove<
d[1].compare<
d[1].remove<
d[2].compare<
d[2].remove<
=======================\n"
binsertsort（data[0]）;
binsertsort（data[1]）;
binsertsort（data[2]）;
selectsort（data[0]）;
selectsort（data[1]）;
selectsort（data[2]）;
bubblesort（data[0]）;
bubblesort（data[1]）;
bubblesort（data[2]）;
shellsort（data[0]）;
shellsort（data[1]）;
shellsort（data[2]）;
quicksortx（data[0]）;
quicksortx（data[1]）;
quicksortx（data[2]）;
r[0].length=10;
mergesort（data[0],r[0]）;
r[1].length=50;
mergesort（data[1],r[1]）;
r[2].length=100;
mergesort（data[2],r[2]）;
插入排序\n直接插入排序是一种稳定的排序\n折半插入排序减少了记录关键字之间的比较次数，而未改变记录的移动次数\n"
希尔排序是对直接插入排序的一种改进算法，它是一种不稳定的排序方法\n"
交换排序：
\n冒泡排序是一种简单的交换排序，是一种稳定的排序方法\n快速排序是对冒泡排序的一种改进是一种不稳定的排序方法\n"
归并排序是一种不稳定的排序\n"
voidmain（）
lists;
while
（1）{
\n***主菜单***"
+++++++++++++++++++++++++++++++++++++"
||||"
||1.随机生成十个数||"
||2.随机生成三十个数||"
||3.随机生成五十个数||"
||4.随机生成一百个数||"
||5.对比||"
||6.键盘输入任意个数||"
||0=>
退出||"
++++++++++++++++++++++++++++++++++++"
请选择：
switch（n）
case1:
s.play1（10）;
break;
case2:
s.play1（30）;
case3:
s.play1（50）;
case4:
s.play1（100）;
case5:
s.play3（）;
case6:
s.play2（）;
case0:
exit（0）;
default:
输入错误!
请重新输入"
升级会员 