交换排序

成绩评定表

课程设计任务书

目录

一、题目概述（内容及要求） (4)

二、功能分析 (4)

三、设计 (6)

四、运行与测试 (9)

五、总结 (10)

参考文献 (11)

一、题目概述（内容及要求）

实验内容：

输入数据对数据按菜单选择对数据进行交换排序。

实验要求：

1.菜单列出所有交换排序。

2.对数据按菜单选择的进行排序。

3.统计比较和交换的次数。

二、功能分析

1.交换排序：

分为冒泡排序和快速排序

2.交换排序算法分析

（1）冒泡排序

基本思想：设排序表中有n个数据元素。首先对排序表中第一，二个数据元素的关键字arr[0]和arr[1]进行比较。如果前者大于后者，则进行交换；然后对第二，三个数据做同样的处理；重复此过程直到处理完最后两个相邻的数据元素。我们称之为一趟冒泡，它将关键字最大的元素移到排序表的最后一个位置，其他数据元素一般也都向排序的最终位置移动。然后进行第二趟排序，对排序表中前n-1个元素进行与上述同样的操作，其结果使整个排序表中关键字次大的数据元素被移到arr[n-2]的位置。如此最多做n-1趟冒泡就能把所有数据元素排好序。

（2）快速排序

基本思想：快速排序（Quick Sort）又被称做分区交换排序，这是一种平均性能非常好的排序方法。

其算法基本思想是：任取排序表中的某个数据元素(例如取第一个数据元素)作为基准，按照该数据元素的关键字大小，将整个排序表划分为左右两个子表：左侧子表中所有数据元素的关键字都小于基准数据元素的关键字。右侧子表中所有数据元素的关键字都大于或等于基准数据元素的关键字，基准数据元素则排在这两个子表中间(这也是该数据元素最终应安放的位置)，然后分别对这两个子表重复施行上述方法的快速排序，直到所有的子表长度为1，则排序结束。

3.算法性能分析

（1）冒泡排序（稳定的排序算法） 1.时间复杂度：

a.最好情况（正序）

b.比较次数：n-1（只要进行一趟即可）

c.移动次数：0

d.最坏情况（逆序）

e.比较次数：（需n-1趟，每趟达到最大比较次数）

f.移动次数：

在最坏情况下，时间复杂度为:T(n)=O(n2) 2.空间复杂度：S(n)=O(1)

（2）快速排序

快速排序（不稳定的排序方法） 1.时间复杂度

最好情况（每次总是选到中间值作枢轴）T(n)=O(nlog2n) 最坏情况（每次总是选到最小或最大元素作枢轴）T(n)=O(n2) 2.空间复杂度：需栈空间以实现递归 最坏情况：S(n)=O(n) 一般情况：S(n)=O(l og2n)

图2.1 菜单选择流程图

)(21)(2

1

1

n n i n n i -=-∑-=)(23

)(321

n n i n n

i -=-∑=

图2.2 程序整体流程图

三、设计

1.类型定义：

typedef struct {

ElemType *base; //数组元素基址,由InitArray分配

int dim; //数组维数

int *bounds; //新数组元素维界基址,由InitArray分配

int *constants; //数组映象函数常量基址,由InitArray分配}

2.算法分析：

（1）快速排序算法分析

任取排序表中的某个数据元素(例如取第一个数据元素)作为基准，按照该数据元素的关键字大小，将整个排序表划分为左右两个子表：左侧子表中所有数据元素的关键字都小于基准数据元素的关键字。右侧子表中所有数据元素的关键字都大于或等于基准数据元素的关键字，基准数据元素则排在这两个子表中间(这也是该数据元素最终应安放的位置)，然后分别对这两个子表重复施行上述方法的快速排序，直到所有的子表长度为1，则排序结束。

（2）冒泡排序算法分析

设排序表中有n个数据元素。首先对排序表中第一，二个数据元素的关键字arr[0]和arr[1]进行比较。如果前者大于后者，则进行交换；然后对第二，三个数据做同样的处理；重复此过程直到处理完最后两个相邻的数据元素。我们称之为一趟冒泡，它将关键字最大的元素移到排序表的最后一个位置，其他数据元素一般也都向排序的最终位置移动。然后进行第二趟排序，对排序表中前n-1个元素进行与上述同样的操作，其结果使整个排序表中关键字次大的数据元素被移到arr[n-2]的位置。如此最多做n-1趟冒泡就能把所有数据元素排好序。

3.算法描述：

（1）冒泡排序的算法

伪代码如下：

template //冒泡排序

void sortlist:: bubblesort()

{

int i=1;

int finish=0;//0表示还没有排好序

while(i

{

finish=1;//排序结束标志置为,假定已经排好序

for(int j=0;j

if(arr[j]>arr[j+1])//逆序

{

swap(arr[j],arr[j+1]);//相邻元素交换位置

finish=0;

}//排序结束标志置为,表示本趟发生了交换，说明还没有排好序

i++;

cout<<"第"<<++num<<"趟排序结果为:";

for(int t=0;t

cout<

cout<

}

num=0;

}

（2）快速排序的具体算法

template //快速排序

void sortlist::quicksort(int low,int high)//在待排序区间[low,high]上，递归地进行快速排序

{

int i=low,j=high;

type temp=arr[low];//取区间第一个位置为基准位置

if(i

{

while(i

{

while(i

if(i

while(i=arr[i])i++;

if(i

}

arr[i]=temp;//将基准元素就位

cout<<"第"<<++x<<"趟排序结果为:";

for(int t=0;t

cout<

cout<

quicksort(low,i-1);//在左子区间递归进行快速排序

quicksort(i+1,high);//在右子区间递归进行快速排序

}

}

4.程序的主要模块设计

<1>主菜单

主要功能：程序运行时，可使运行者根据提醒输入相关操作，从而进入不同的排序方法或者退出。

<2>排序方法及输出

根据运行者对排序的不同选择，进入排序过程

(a).冒泡排序：根据冒泡排序算法，输出排序过程

(b).快速排序：根据快速排序的算法，输出排序过程

四、运行与测试

待测试的数据保存在data.txt记事本中，具体数据如下：

图4.1测试数据

预期显示结果为：

0 1 2 3 4 5 5 6 6 8 11 11 12 16 16 18 21 22 23 23 23 24 26 26 27 27 29 29 29 29 31 33 34 35 36 37 37 38 38 39 40 40 41 41 41 42 42 42 44 44 45 46 47 47 48 48 50 53 53 54 56 57 58 59 61 62 62 64 64 64 66 67 67 68 69 69 70 71 73 76 78 81 82 82 84 84 88 90 90 91 91 92 93 94 95 95 99

图4.2选择菜单

图4.3排序结果及关键字比较次数

五、总结

本课程设计对我来说是比较难的，最终完成了算法。这期间，遇到了各种麻烦，但是我并没有放弃,反复修改代码，经过不懈的努力，问题都相继解决。从这次实践中，我意识到自己还有很多不足之处。

首先先说一下基本的。对于各种排序算法的过程还是不够熟悉，进行编程时还需要翻书查找，对于这一点，只能说对数据结构的学习还不够扎实，虽然说这门课程以后就没有了，但是我想这门课对以后的学习会有很大帮助，所以有空时还应该继续熟悉这门课程。

其次，就是对于错误的处理，不能得心应手，不能正确处理一些简单的错误。对于逻辑上的错误，不能够立即找到出错点，往往需要向同学请教才能找出错误，并且改正。我觉得这是自己独自思考能力不高的问题，遇事需要自己仔细想想，若还不能改正，再请教别人也不迟。

这次试验我发现书本上的知识是一个基础，但是我基础都没掌握，更别说写出一个整整的程序了。自己在写程序的时候，也发现自己的知识太少了，特别是基础知识很多都是模模糊糊的一个概念，没有落实到真正的程序，所以自己写的时候也感到万分痛苦，基本上涉及一个知识我就会看看书，对于书本上的知识没掌握好。认真上好专业实验课，多在实践中锻炼自己。写程序的过程中要考虑周到，严密。在做设计的时候要有信心，有耐心，切勿浮躁。巩固和加深了对数据结构的理解，提高综合运用本课程所学知识的能力。通过实际编译系统的分析设计、编程调试，掌握应用软件的分析方法和工程设计方法。培养了我选用参考书，查阅手册及文献资料的能力。培养独立思考，深入研究，分析问题解决问题的能力。通过课程设计，培养了我严肃认真的工作作风，逐步建立正确的生产观念、经济观念全局观念。

总而言之，从这次的实践中我学到了很多东西，希望以后能够多加运应。

参考文献

1).《数据结构(C语言版)》严蔚敏吴伟民编著清华大学出版社

2).《C语言程序设计第二版》谭浩强编著清华大学出版社

附件：

程序代码：

#include

#include

#include

#include

#define LIST_INIT_SIZE 50000

int bj1,yd1,n;

clock_t start_t,end_t;

typedef struct

{ int key;}ElemType;

typedef struct

{ ElemType *elem;

int length;

}SqList;

void addlist(SqList &L)

{ int i;

a: printf("请输入你要输入的个数:");

scanf("%d",&n);

if(n>50000)

{ printf("超出范围重新输入!!!\n");

goto a; }

L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));

if(!L.elem)exit(0);

L.length=0;

for(i=1;i

{ b: L.elem[i].key=rand();

if(L.elem[i].key>30000)goto b;

++L.length; }

}

//选择

void SelectSort(SqList &L)

{ start_t=clock();

int i,j,k,bj=0,yd=0;

for(i=1;i

{ k=i;

for(j=i+1;j

{ bj++;

if(L.elem[j].key

if(i!=k)

{ L.elem[0].key=L.elem[i].key;

L.elem[i].key=L.elem[k].key;

L.elem[k].key=L.elem[0].key;

yd+=3;

}

}

end_t=clock();

printf("比较次数为%d移动次数为%d\n",bj,yd);

printf("排序用时为%f\n",float(end_t-start_t)/CLK_TCK); }

//起泡

void qipao(SqList &L)

{ start_t=clock();

int i=1,j,bj=0,yd=0;

while(i

{ for(j=1;j

{ bj++;

if(L.elem[j].key>L.elem[j+1].key)

{ L.elem[0].key=L.elem[j].key;

L.elem[j].key=L.elem[j+1].key;

L.elem[j+1].key=L.elem[0].key;

yd+=3;

}

}

i++;

}

end_t=clock();

printf("比较次数为%d移动次数为%d\n",bj,yd);

printf("排序用时为%f\n",float(end_t-start_t)/CLK_TCK); }

//直接插入

void InsertSort(SqList &L)

{ start_t=clock();

int i,j,yd=0,bj=0;

for(i=2;i<=L.length;i++)

if(L.elem[i].key

{

L.elem[0].key=L.elem[i].key;

yd++;

j=i-1;

bj++;

while(L.elem[0].key

{

L.elem[j+1].key=L.elem[j].key;

j--;

yd++;

bj++;

}

L.elem[j+1].key=L.elem[0].key;

yd++;

}

}

end_t=clock();

printf("比较次数为%d移动次数为%d\n",bj,yd);

printf("排序用时为%f\n",float(end_t-start_t)/CLK_TCK); }

//希尔

void xier(SqList &L)

{

start_t=clock();

int i,d=L.length/2,j,w=0,k,yd=0,bj=0;

while(w

w=1;

for(i=w;i

{

k=i;

for(j=i+d;j

{

if(L.elem[i].key>L.elem[j].key)

{

k=j;

bj++;

}

}

if(i!=k)

{

L.elem[0].key=L.elem[i].key;

L.elem[i].key=L.elem[k].key;

L.elem[k].key=L.elem[0].key;

yd+=3;

}

w++;

}

d=d/2;

w=1;

}

end_t=clock();

printf("比较次数为%d移动次数为%d\n",bj,yd);

printf("排序用时为%f\n",float(end_t-start_t)/CLK_TCK); }

void BeforeSort()

{

yd1=0,bj1=0;

}

void display(int m,int n)

{

printf("比较次数为%d移动次数为%d\n",m,n);

}

int Partition(SqList &L,int low,int high)//快速排序

{

int pivotkey;

L.elem[0]=L.elem[low];

yd1++;

pivotkey=L.elem[low].key;

while (low

{

yd1++;

while(low=pivotkey)

--high;

L.elem[low]=L.elem[high];

bj1++;

yd1++;

while (low

++low;

L.elem[high]=L.elem[low];

bj1++;

yd1++;

}

L.elem[low]=L.elem[0];

yd1++;

return low;

}

void QSort(SqList &L,int low,int high)

{

int pivotloc;

if(low

{

pivotloc=Partition(L,low,high);

QSort(L,low,pivotloc-1);

QSort(L,pivotloc+1,high);

}

}

void QuickSort(SqList &L)

{

start_t=clock();

BeforeSort();

QSort(L,1,L.length);

display(yd1,bj1);

end_t=clock();

printf("排序用时为%f\n",float(end_t-start_t)/CLK_TCK); }

void Merge(ElemType R[],ElemType R1[],int low,int m,int high)//归并{

int i=low, j=m+1, k=low;

while(i<=m&&j<=high)

{

if(R[i].key<=R[j].key)

{

bj1++;

R1[k]=R[i];

yd1++;

i++;

k++;

}

else

{

bj1++;

R1[k]=R[j];

yd1++;

j++;

k++;

}

}

while(i<=m)

{

R1[k]=R[i];

yd1++;

i++;

k++;

while(j<=high)

{

R1[k]=R[j];

yd1++;

j++;

k++;

}

}

void MergePass(ElemType R[],ElemType R1[],int length, int n) { int i=0,j;

while(i+2*length-1

{ Merge(R,R1,i,i+length-1,i+2*length-1);

i=i+2*length;

}

if(i+length-1

Merge(R,R1,i,i+length-1,n-1);

else

for(j=i;j

R1[j]=R[j];

}

void MSort(ElemType R[],ElemType R1[],int n)

{ int length=1;

while (length

{

MergePass(R,R1,length,n);

length=2*length;

MergePass(R1,R,length,n);

length=2*length;

}

void MergeSort(SqList &L)

{ start_t=clock();

BeforeSort();

MSort(L.elem,L.elem,L.length);

display(yd1,bj1);

end_t=clock();

printf("排序用时为%f\n",float(end_t-start_t)/CLK_TCK); }

int main()

{ SqList L;

addlist(L);

printf("起泡排序: \n");

qipao(L);

printf("直插排序: \n");

InsertSort(L);

printf("选择排序: \n");

SelectSort(L);

printf("希尔排序: \n");

xier(L);

printf("快速排续: \n");

QuickSort(L);

printf("归并排序: \n");

MergeSort(L);

}