实验六各种排序方法的比较switch选择方法Word格式文档下载.docx
《实验六各种排序方法的比较switch选择方法Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《实验六各种排序方法的比较switch选择方法Word格式文档下载.docx（11页珍藏版）》请在冰豆网上搜索。
RecordNode*record;
}SortObject;
structNode;
typedefstructNodeListNode;
structNode
{
ListNode*next;
};
typedefListNode*LinkList;
/*对链表按递增序进行表插入排序，链表中第一个结点为表头结点*/
voidlistSort（LinkList*plist）
ListNode*now,*pre,*p,*q,*head;
head=*plist;
pre=head->
next;
if（pre==NULL）return;
now=pre->
if（now==NULL）return;
while（now!
=NULL）
{
q=head;
p=head->
while（p!
=now&
&
p->
key<
=now->
key）{q=p;
p=p->
}
if（p==now）{pre=pre->
now=pre->
continue;
pre->
next=now->
q->
next=now;
now->
next=p;
}
}
/*Shell排序*/
voidshellSort（SortObject*pvector,intd）
inti,j,increment;
RecordNodetemp;
for（increment=d;
increment>
0;
increment/=2）
{
for（i=increment;
i<
pvector->
n;
i++）
{
temp=pvector->
record[i];
j=i-increment;
while（j>
=0&
temp.key<
record[j].key）
pvector->
record[j+increment]=pvector->
record[j];
j-=increment;
}
record[j+increment]=temp;
}
/*直接选择排序*/
voidselectSort（SortObject*pvector）
inti,j,k;
for（i=0;
i<
n-1;
i++）
k=i;
for（j=i+1;
j<
j++）
if（pvector->
record[j].key<
record[k].key）k=j;
if（k!
=i）
{
record[i]=pvector->
record[k];
record[k]=temp;
}
/*冒泡排序*/
voidbubbleSort（SortObject*pvector）
inti,j,noswap;
for（i=0;
{
noswap=TRUE;
for（j=0;
n-i-1;
j++）
record[j+1].key<
record[j]=pvector->
record[j+1];
record[j+1]=temp;
noswap=FALSE;
if（noswap）break;
/*快速排序*/
voidquickSort（SortObject*pvector,intl,intr）
inti,j;
if（l>
=r）return;
i=l;
j=r;
while（i!
=j）
while（（pvector->
record[j].key>
=temp.key）&
（j>
i））j--;
if（i<
j）pvector->
record[i++]=pvector->
record[j];
record[i].key<
i））i++;
record[j--]=pvector->
record[i]=temp;
quickSort（pvector,l,i-1）;
quickSort（pvector,i+1,r）;
/*二組歸併算法算法*/
voidmerge（RecordNode*r,RecordNode*r1,intlow,intm,inthigh）
inti,j,k;
i=low;
j=m+1;
k=low;
while（（i<
=m）&
（j<
=high））
if（r[i].key<
=r[j].key）r1[k++]=r[i++];
elser1[k++]=r[j++];
while（i<
=m）r1[k++]=r[i++];
while（j<
=high）r1[k++]=r[j++];
/*对r做一趟归并，结果放在r1中*/
voidmergePass（RecordNode*r,RecordNode*r1,intn,intlength）{
intj,i=0;
while（i+2*length-1<
n）
merge（r,r1,i,i+length-1,i+2*length-1）;
i+=2*length;
if（i+length-1<
n-1）
merge（r,r1,i,i+length-1,n-1）;
else
for（j=i;
j++）r1[j]=r[j];
/*二路歸並排序法*/
voidmergeSort（SortObject*pvector）
RecordNoderecord[N];
intlength=1;
while（length<
mergePass（pvector->
record,record,pvector->
n,length）;
length*=2;
mergePass（record,pvector->
record,pvector->
voids1（）/*Shell排序*/
inti;
SortObject*p3=（SortObject*）malloc（sizeof（SortObject））;
p3->
n=10;
record=（RecordNode*）malloc（sizeof（RecordNode）*p3->
n）;
i<
p3->
i++）
record[i].key=a[i];
shellSort（p3,4）;
printf（"
Shell排序后:
"
）;
%d"
p3->
record[i].key）;
\n"
voids2（）/*直接选择排序*/
SortObject*p4=（SortObject*）malloc（sizeof（SortObject））;
p4->
record=（RecordNode*）malloc（sizeof（RecordNode）*p4->
p4->
selectSort（p4）;
直接选择排序后:
p4->
voids3（）/*冒泡排序*/
SortObject*p5=（SortObject*）malloc（sizeof（SortObject））;
p5->
record=（RecordNode*）malloc（sizeof（RecordNode）*p5->
p5->
bubbleSort（p5）;
起泡排序后:
p5->
voids4（）/*快速排序*/
SortObject*p6=（SortObject*）malloc（sizeof（SortObject））;
p6->
record=（RecordNode*）malloc（sizeof（RecordNode）*p6->
p6->
quickSort（p6,0,p6->
n-1）;
快速排序后:
p6->
voids5（）/*二路归并排序*/
SortObject*p7=（SortObject*）malloc（sizeof（SortObject））;
p7->
record=（RecordNode*）malloc（sizeof（RecordNode）*p7->
p7->
mergeSort（p7）;
二路归并排序后:
p7->
voidmain（）
inti,b;
實驗六：
各種排序算法的比較\n"
根據已知得出排序前的結果是:
10;
a[i]）;
\n\n"
各類排序算法以及算法的選擇如下：
1——Shell排序法\n"
2——直接選擇排序法\n"
3——冒泡排序法\n"
4——快速排序法\n"
5——二路歸並排序法\n"
0——結束\n"
\n\n請選擇一種方法并輸出:
scanf（"
%d"
&
b）;
while
（1）
switch（b）
case1:
s1（）;
break;
case2:
s2（）;
break;
case3:
s3（）;
case4:
s4（）;
case5:
s5（）;
case0:
exit（0）;
\n請再接著選擇一個并輸出（0——结束）：
"
实验结果截图：
升级会员 