实验六各种排序方法的比较switch选择方法.docx

实验六各种排序方法的比较switch选择方法.docx

《实验六各种排序方法的比较switch选择方法.docx》由会员分享，可在线阅读，更多相关《实验六各种排序方法的比较switch选择方法.docx（11页珍藏版）》请在冰豆网上搜索。

实验六各种排序方法的比较switch选择方法

实验六各种排序方法的比较

一、实验目的

1．通过实验掌握排序的基本概念，对排序的稳定性及排序的时间复杂性有深刻的认识。

2．掌握各种排序方法的基本思想和算法实现。

3．能够灵活地选用某种排序方法解决问题。

二、实验要求

1．认真阅读和掌握本实验的参考程序。

2．保存程序的运行结果，并结合程序进行分析。

三、实验内容

编写一个程序，对所给的数据（程序中给出或通过键盘初始化均可）进行排序，要求尽可能多的选择不同的排序算法，并显示排序前和排序后的结果。

实验详细代码：

#include

#include

#defineTRUE1

#defineFALSE0

#defineN10

inta[10]={49,37,65,97,76,13,27,49,7,71};

typedefintKeyType;

typedefintDataType;

typedefstruct

{

KeyTypekey;

DataTypeinfo;

}RecordNode;

typedefstructSort

{

intn;

RecordNode*record;

}SortObject;

structNode;

typedefstructNodeListNode;

structNode

{

KeyTypekey;

ListNode*next;

};

typedefListNode*LinkList;

/*对链表按递增序进行表插入排序，链表中第一个结点为表头结点*/

voidlistSort（LinkList*plist）

{

ListNode*now,*pre,*p,*q,*head;

head=*plist;

pre=head->next;

if（pre==NULL）return;

now=pre->next;

if（now==NULL）return;

while（now!

=NULL）

{

q=head;p=head->next;

while（p!

=now&&p->key<=now->key）{q=p;p=p->next;}

if（p==now）{pre=pre->next;now=pre->next;continue;}

pre->next=now->next;

q->next=now;now->next=p;

now=pre->next;

}

}

/*Shell排序*/

voidshellSort（SortObject*pvector,intd）

{

inti,j,increment;

RecordNodetemp;

for（increment=d;increment>0;increment/=2）

{

for（i=increment;in;i++）

{

temp=pvector->record[i];

j=i-increment;

while（j>=0&&temp.keyrecord[j].key）

{

pvector->record[j+increment]=pvector->record[j];

j-=increment;

}

pvector->record[j+increment]=temp;

}

}

}

/*直接选择排序*/

voidselectSort（SortObject*pvector）

{

inti,j,k;

RecordNodetemp;

for（i=0;in-1;i++）

{

k=i;

for（j=i+1;jn;j++）

if（pvector->record[j].keyrecord[k].key）k=j;

if（k!

=i）

{

temp=pvector->record[i];

pvector->record[i]=pvector->record[k];

pvector->record[k]=temp;

}

}

}

/*冒泡排序*/

voidbubbleSort（SortObject*pvector）

{

inti,j,noswap;

RecordNodetemp;

for（i=0;in-1;i++）

{

noswap=TRUE;

for（j=0;jn-i-1;j++）

if（pvector->record[j+1].keyrecord[j].key）

{

temp=pvector->record[j];

pvector->record[j]=pvector->record[j+1];

pvector->record[j+1]=temp;

noswap=FALSE;

}

if（noswap）break;

}

}

/*快速排序*/

voidquickSort（SortObject*pvector,intl,intr）

{

inti,j;

RecordNodetemp;

if（l>=r）return;

i=l;j=r;temp=pvector->record[i];

while（i!

=j）

{

while（（pvector->record[j].key>=temp.key）&&（j>i））j--;

if（irecord[i++]=pvector->record[j];

while（（pvector->record[i].key<=temp.key）&&（j>i））i++;

if（irecord[j--]=pvector->record[i];

}

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

{

merge（r,r1,i,i+length-1,i+2*length-1）;

i+=2*length;

}

if（i+length-1

merge（r,r1,i,i+length-1,n-1）;

else

for（j=i;j

}

/*二路歸並排序法*/

voidmergeSort（SortObject*pvector）

{

RecordNoderecord[N];

intlength=1;

while（lengthn）

{

mergePass（pvector->record,record,pvector->n,length）;

length*=2;

mergePass（record,pvector->record,pvector->n,length）;

length*=2;

}

}

voids1（）/*Shell排序*/

{

inti;

SortObject*p3=（SortObject*）malloc（sizeof（SortObject））;

p3->n=10;

p3->record=（RecordNode*）malloc（sizeof（RecordNode）*p3->n）;

for（i=0;in;i++）

p3->record[i].key=a[i];

shellSort（p3,4）;

printf（"Shell排序后:

"）;

for（i=0;in;i++）

printf（"%d",p3->record[i].key）;

printf（"\n"）;

}

voids2（）/*直接选择排序*/

{

inti;

SortObject*p4=（SortObject*）malloc（sizeof（SortObject））;

p4->n=10;

p4->record=（RecordNode*）malloc（sizeof（RecordNode）*p4->n）;

for（i=0;in;i++）

p4->record[i].key=a[i];

selectSort（p4）;

printf（"直接选择排序后:

"）;

for（i=0;in;i++）

printf（"%d",p4->record[i].key）;

printf（"\n"）;

}

voids3（）/*冒泡排序*/

{

inti;

SortObject*p5=（SortObject*）malloc（sizeof（SortObject））;

p5->n=10;

p5->record=（RecordNode*）malloc（sizeof（RecordNode）*p5->n）;

for（i=0;in;i++）

p5->record[i].key=a[i];

bubbleSort（p5）;

printf（"起泡排序后:

"）;

for（i=0;in;i++）

printf（"%d",p5->record[i].key）;

printf（"\n"）;

}

voids4（）/*快速排序*/

{

inti;

SortObject*p6=（SortObject*）malloc（sizeof（SortObject））;

p6->n=10;

p6->record=（RecordNode*）malloc（sizeof（RecordNode）*p6->n）;

for（i=0;in;i++）

p6->record[i].key=a[i];

quickSort（p6,0,p6->n-1）;

printf（"快速排序后:

"）;

for（i=0;in;i++）

printf（"%d",p6->record[i].key）;

printf（"\n"）;

}

voids5（）/*二路归并排序*/

{

inti;

SortObject*p7=（SortObject*）malloc（sizeof（SortObject））;

p7->n=10;

p7->record=（RecordNode*）malloc（sizeof（RecordNode）*p7->n）;

for（i=0;in;i++）

p7->record[i].key=a[i];

mergeSort（p7）;

printf（"二路归并排序后:

"）;

for（i=0;in;i++）

printf（"%d",p7->record[i].key）;

printf（"\n"）;

}

voidmain（）

{

inti,b;

printf（"實驗六：

各種排序算法的比較\n"）;

printf（"根據已知得出排序前的結果是:

"）;

for（i=0;i<10;i++）

printf（"%d",a[i]）;

printf（"\n\n"）;

printf（"各類排序算法以及算法的選擇如下：

\n\n"）;

printf（"1——Shell排序法\n"）;

printf（"2——直接選擇排序法\n"）;

printf（"3——冒泡排序法\n"）;

printf（"4——快速排序法\n"）;

printf（"5——二路歸並排序法\n"）;

printf（"0——結束\n"）;

printf（"\n\n請選擇一種方法并輸出:

"）;

scanf（"%d",&b）;

printf（"\n\n"）;

while

（1）

{

switch（b）

{

case1:

s1（）;break;

case2:

s2（）;break;

case3:

s3（）;break;

case4:

s4（）;break;

case5:

s5（）;break;

case0:

exit（0）;

}

printf（"\n請再接著選擇一個并輸出（0——结束）：

"）;

scanf（"%d",&b）;

printf（"\n"）;

}

}

实验结果截图：