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

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

一、实验目的

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

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

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

二、实验要求

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

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

三、实验内容

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

实验详细代码：

#include

#include

#define TRUE 1

#define FALSE 0

#define N 10

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

typedef int KeyType;

typedef int DataType;

typedef struct

{

KeyType key;

DataType info;

}RecordNode;

typedef struct Sort

{

int n;

RecordNode *record;

}SortObject;

struct Node;

typedef struct Node ListNode;

struct Node

{

KeyType key;

ListNode *next;

};

typedef ListNode * LinkList;

/*对链表按递增序进行表插入排序，链表中第一个结点为表头结点*/ void listSort(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排序*/

void shellSort(SortObject * pvector, int d)

{

int i, j, increment;

RecordNode temp;

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;

}

}

}

/*直接选择排序*/

void selectSort(SortObject * pvector)

{

int i, j, k;

RecordNode temp;

for( i = 0; i < pvector->n-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;

}

}

}

/*冒泡排序*/

void bubbleSort(SortObject * pvector)

{

int i, j, noswap;

RecordNode temp;

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;

}

}

/*快速排序*/

void quickSort(SortObject * pvector, int l, int r)

{

int i, j;

RecordNode temp;

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);

}

/*二組歸併算法算法*/

void merge(RecordNode* r, RecordNode *r1, int low, int m, int high) {

int i,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++];

else r1[k++]=r[j++];

}

while (i<=m) r1[k++]=r[i++];

while (j<=high) r1[k++]=r[j++];

}

/*对r做一趟归并，结果放在r1中*/

void mergePass(RecordNode *r, RecordNode *r1, int n, int length){ int j, 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

}

/*二路歸並排序法*/

void mergeSort(SortObject *pvector)

{

RecordNode record[N];

int length =1;

while(lengthn)

{

mergePass(pvector->record,record,pvector->n,length);

length*=2;

mergePass(record,pvector->record,pvector->n,length);

length*=2;

}

}

void s1() /*Shell排序*/

{

int i;

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");

}

void s2() /*直接选择排序*/

{

int i;

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);

for(i=0;in;i++)

printf("%d ",p4->record[i].key);

printf("\n");

}

void s3() /*冒泡排序*/

{

int i;

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");

}

void s4() /*快速排序*/

{

int i;

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);

for(i=0;in;i++)

printf("%d ",p6->record[i].key);

printf("\n");

}

void s5() /*二路归并排序*/

{

int i;

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");

}

void main()

{

int i,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)

{

case 1: s1(); break;

case 2: s2(); break;

case 3: s3(); break;

case 4: s4(); break;

case 5: s5(); break;

case 0: exit(0);

}

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

scanf("%d",&b);

printf("\n");

}

}

实验结果截图：