计算机专业课程设计报告

《数据结构》课程设计报告

设计题目：___ ________________

姓名：______ ________________

学号：_______ 5_________________专业：________网络工程______________

院系：_______计算机科学与技术学院_________班级：_______________

指导教师：______ ________________

2011年 6 月 15 日

摘要：

1.排序的基本概念

(1)排序：将无序的数据序列排列成与关键字有关的数据序列。

2各种排序方法

·希尔排序：先取第一个增量，把距离为第一个增量的倍数的记录放在同一组中，组内进行直接插入排序：再取小于第一增量的第二增量，重复上述的操作。

·快速排序：将原问题分解为若干个小规模的同结构子问题，递归解决每个子问题。

·堆排序：先把序列看成一棵大根堆或小根堆，摘取最大或最小元素后再建成新的根堆，再排序。

·二路归并排序：将两个有序的子文件合并成一个有序文件，再扩大子文件长度，再次执行上述操作。

3．各排序法的比较

·元素较大：快速排序、堆排序、归并排序。

·元素基本有序：直接插入排序、快速排序。

·有益于链表：归并排序。

·不利于链表：快速排序、堆排序。

·就时间性能而言，快速排序最佳。

关键词：排序的概念，各种排序方法，各排序法的比较

英文摘要

Abstract:

1. Sort of basic concepts

(1) sorting: will disorder data sequence arranged and keyword related data

sequence.

(2) internal sort: documents in memory processing, sorting does not involve,exchange within CRT.

(3) the external sort: sorting process to save exchange inside and outside.

(4) sorting stability: if the file to sort, there have DuoGe key word the same record, after sort with the same key words after the record of the relative order between remain unchanged, it says the sorting method is stable; Conversely, if have the same key word records of the relative order between change, it says the sorting method is not stable.

2 all kinds of sorting method

Hill: the first to take the first order the distance for incremental first incremental multiples of records in the same group, the group within the directinsertion sort: take again the next increment of less than first increment, and repeat the operation.

quick sort: will the problem into several small son with structure, a recursive solve every problem son.

heap sort: first the series as a tree root pile of large or small root pile, and gather a maximum or minimum element built again after new root pile of, again in order.

3. The ranking comparison

element bigger: quick sort,

目录

1摘要 (1)

2 问题描述 (3)

3 需求分析 (3)

4 概要设计 (3)

5.数据结构设计 (3)

6 1算法设计 (4)

6.1.1快速排序 (4)

6.1.2二路归并排序 (5)

6.1.3堆排序 (5)

6.1.4希尔排序 (6)

6.2算法实现…………………………………………………………………6.

7.1程序测试与实验 (10)

7.1.1主程序 (10)

7.1.2测试数据 (11)

7.1.3测试结果 (11)

8.性能比较 (12)

9心得体会 (13)

一、问题描述

1．题目内容：要求分别采用快速排序、二路归并排序、堆排序和希尔排序对随机生成的一组数据进行排序（数据不少于100）；

2．完成排序的输入、输出，比较各种排序的性能，界面友好，提供操作菜单。

二、需求分析

分别采用快速排序、二路归并排序、堆排序和希尔排序对随机生成的一组数据进行排序（数据不少于100）；

三、概要设计

将随机产生的数据放在数组data[100 ]中：

操作集合：

int Partition(int r[ ], int first, int end) //快速排序，实现一次划分

void QuickSort (int r[ ], int first, int end ) //在序列first~end中递归地进行快速排序

void ShellSort(int r[],int n) //希尔排序

void Merge (int r[ ], int r1[ ], int s, int m, int t ) //二路归并排序void MergePass (int r[ ], int r1[ ], int n, int h)

void sift(int r[],int k,int m)//堆排序

void heapsort(int r[],int n)

四、数据结构设计

1．元素类型

int data[] //定义数组

五、算法设计

1、算法分析

1）、快速排序

快速排序的基本思想：

首先选一个轴值（即比较的基准），通过一趟排序将待排序记录分割成独立的两

部分，前一部分记录的关键码均小于或等于轴值，后一部分记录的关键码均大于或等于轴值，然后分别对这两部分重复上述方法，直到整个序列有序。

需解决的关键问题：

⑴如何选择轴值？

选择轴值的方法：

1.使用第一个记录的关键码；

2.选取序列中间记录的关键码；

3.比较序列中第一个记录、最后一个记录和中间记录的关键码，取关键码居中的作为轴值并调换到第一个记录的位置；

4.随机选取轴值。

⑵如何实现分割（称一次划分）？

解决方法：

设待划分的序列是r[s] ~ r[t]，设参数i，j分别指向子序列左、右两端的下标s和t，令r[s]为轴值，

（1）j从后向前扫描，直到r[j]

（2）i从前向后扫描，直到r[i]＞r[j]，将r[i]移动到r[j]的位置，使关键码大（同轴值比较）的记录移动到后面去；

（3）重复上述过程，直到i=j。

⑶如何处理分割得到的两个待排序子序列？

解决方法：

对分割得到的两个子序列递归地执行快速排序。

⑷如何判别快速排序的结束？

解决方法：

若待排序列中只有一个记录，显然已有序，否则进行一次划分后，再分别对分割所得的两个子序列进行快速排序（即递归处理）。

2）、二路归并排序

基本思想：将一个具有n个待排序记录的序列看成是n个长度为1的有序序列，然后进行两两归并，得到n/2个长度为2的有序序列，再进行两两归并，得到n/4个长度为4的有序序列，……，直至得到一个长度为n的有序序列为止。

需解决的关键问题：

⑴如何将两个有序序列合成一个有序序列？

void Merge (int r[ ], int r1[ ], int s, int m, int t )

{

i=s; j=m+1; k=s;

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

{

if (r[i]<=r[j]) r1[k++]=r[i++];

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

}

if (i<=m) while (i<=m) //收尾处理

r1[k++]=r[i++]; //前一个子序列

else while (j<=t)

r1[k++]=r[j++]; //后一个子序列

}

⑵怎样完成一趟归并？

设参数i指向待归并序列的第一个记录，归并的步长是2h，

在归并过程中，有以下三种情况：

①若i≤n-2h+1，则相邻两个有序表的长度均为h，执行一次归并，完成后i加2h，准备进行下一次归并；

②若i＜n-h+1，则表示仍有两个相邻有序表，一个长度为h，另一个长度小于h，则执行两个有序表的归并，完成后退出一趟归并。

③若i≥n-h+1，则表明只剩下一个有序表，直接将该有序表送到r1的相应位置，完成后退出一趟归并。

⑶如何控制二路归并的结束？

算法描述：

void MergeSort (int r[ ], int r1[ ], int n )

{

h=1;

while (h

{

MergePass (r, r1, n, h);

h=2*h;

MergePass (r1, r, n, h);

h=2*h;

}

}

3）堆排序

基本思想：首先将待排序的记录序列构造成一个堆，此时，选出了堆中所有记录的最大者，然后将它从堆中移走，并将剩余的记录再调整成堆，这样又找出了次小的记录，以此类推，直到堆中只有一个记录。

⑴如何由一个无序序列建成一个堆（即初始建堆）？

算法描述：

for (i=n/2; i>=1; i--)

sift(r, i, n) ;

最后一个结点（叶子）的序号是n，

则最后一个分支结点即为结点n的双亲，

其序号是n/2。

⑵如何处理堆顶记录？

解决方法：

第i 次处理堆顶是将堆顶记录r[1]与序列中第n-i+1个记录r[n-i+1]交换。

⑶如何调整剩余记录，成为一个新堆（即重建堆）？

解决方法：

第i 次调整剩余记录，此时，剩余记录有n-i个，调整根结点至第n-i个记录。

4）希尔排序

基本思想：将整个待排序记录分割成若干个子序列，在子序列内分别进行直接插入排序，待整个序列中的记录基本有序时，对全体记录进行直接插入排序。（1）应如何分割待排序记录，才能保证整个序列逐步向基本有序发展？

解决方法：

将相隔某个“增量”的记录组成一个子序列。

增量应如何取？

希尔最早提出的方法是d1=n/2，di+1=di/2。

（2）子序列内如何进行直接插入排序？

解决方法：

在插入记录r[i]时，自r[i-d]起往前跳跃式（跳跃幅度为d）搜索待插入位置，并且r[只是暂存单元，不是哨兵。当搜索位置＜0，表示插入位置已找到。

在搜索过程中，记录后移也是跳跃d个位置。

在整个序列中，前d个记录分别是d个子序列中的第一个记录，所以从第d+1

个记录开始进行插入。

2、算法实现

#include"stdafx.h"

#include

#include

using namespace std;

//快速排序

int Partition(int r[ ], int first, int end)//实现一次划分

{

int temp,i,j;

i=first; j=end; //初始化

while (i

{

while (i

j--; //右侧扫描

if (i

{

temp=r[i];

r[i]=r[j];

r[j]=temp;

i++; //将较小记录交换到前面

}

while (i

i++; //左侧扫描

if (i

{

temp=r[j];

r[j]=r[i];

r[i]=temp;

j--; //将较大记录交换到后面

}

}

return i; //i为轴值记录的最终位置

}

void QuickSort (int r[ ], int first, int end )

{//在序列first~end中递归地进行快速排序

if (first < end) {

int pivotpos = Partition (r, first, end );

QuickSort (r, first, pivotpos-1);//对前一个子序列进行快速排序

QuickSort (r, pivotpos+1, end );//对后一个子序列进行快速排序

}

}

//希尔排序

void ShellSort(int r[],int n)

{

for (int d=n/2; d>=1; d=d/2)

{

for (int i=d+1; i<=n; i++) //将r[i]插入到所属的子序列中

{

int j;

r[0]=r[i]; //暂存待插入记录

j=i-d; //j指向所属子序列的最后一个记录while (j>0 && r[0]

{

r[j+d]=r[j]; //记录后移d个位置

j=j-d; //比较同一子序列的前一个记录

}

r[j+d]=r[0];

}

}

}

//二路归并排序

void Merge (int r[ ], int r1[ ], int s, int m, int t )

{

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

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

{

if (r[i]<=r[j]) r1[k++]=r[i++];

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

}

if (i<=m) while (i<=m) //收尾处理

r1[k++]=r[i++]; //前一个子序列else while (j<=t)

r1[k++]=r[j++]; //后一个子序列}

void MergePass (int r[ ], int r1[ ], int n, int h)

{

int i=1;

while (i<=n-2*h+1) //情况

{

Merge (r, r1, i, i+h-1, i+2*h-1);

i+=2*h;

}

if (i

else for (int k=i; k<=n; k++) //情况

r1[k]=r[k];

}

void MergeSort (int r[ ], int r1[ ], int n )

{

int h=1;

while (h

{

MergePass (r, r1, n, h);

h=2*h;

MergePass (r1, r, n, h);

h=2*h;

}

}

//堆排序

void sift(int r[],int k,int m)

{

int i,j,x; int t; bool finished;

i=k; j=2*i;

t=r[k]; x=t; finished=false;

while ((j<=m)&& (! finished))

{ if ((j r[j+1])) j=j+1;

if ( x<= r[j]) finished=true;

else

{ r[i]=r[j]; i=j; j=2*i;

};

};

r[i]=t;

}

void heapsort(int r[],int n)

{

int i,m; int t;

m=n / 2;

for(i=m;i>=1;i--) sift(r,i,n);

for(i=n;i>=2;i--)

{ t=r[1]; r[1]=r[i]; r[i]=t;

sift(r,1,i-1);

}

}

int main()

{

int data[101],data1[101],data2[100],c;

cout<<"随机产生个随机数为"<

for(int i=1;i<=100;i++)

data[i]=10+rand()%(500);

for(int i=1;i<=100;i++)

cout<

cout<

cout<

for(int i=0;i<100;i++)

while(1){

cout<<"0：快速排序 \n";

cout<<"1: 希尔排序 \n";

cout<<"2: 二路归并排序 \n";

cout<<"3: 堆排序 \n";

cout<<"4：退出 \n";

cout<<" 请输入(0--4): \n";

cin>>c;

switch(c){

case 0: QuickSort(data,1,100);

cout<<"快速排序后的序列为:"<

for(int i = 1; i<=100; i++){

cout << data[i] << " ";}

cout<

cout<

case 1: ShellSort(data,100);

cout << "希尔排序后的序列为:"<

for(int i = 1; i<=100; i++){

cout << data[i] << " "; }

cout<

cout<

case 2: MergeSort(data,data1,100);

cout << "二路归并排序后的序列为:"<

for(int i = 0; i<100; i++){

cout << data[i] << " "; }

cout<

cout<

case 3:heapsort(data ,100);

cout<<"堆排序后的序列为:"<

for(int i = 1; i<=100; i++){

cout << data[i] << " ";}

cout<

case 4:return 0; break;

}

}

return 0;

}

六、程序测试与实现

1、主程序

void main() // {

int data[101],data1[101],data2[100],c;

cout<<"随机产生个随机数为"<

for(int i=1;i<=100;i++)

data[i]=10+rand()%(500);

for(int i=1;i<=100;i++)

cout<

cout<

cout<

for(int i=0;i<100;i++)

while(1){

cout<<"0：快速排序 \n";

cout<<"1: 希尔排序 \n";

cout<<"2: 二路归并排序 \n";

cout<<"3: 堆排序 \n";

cout<<"4：退出 \n";

cout<<" 请输入(0--4): \n";

cin>>c;

}

3、测试数据

4、测试结果

七、各种排序方法的比较

对排序算法应该从以下几个方面综合考虑：

⑶稳定性；

所有排序方法可分为两类，

（1）一类是稳定的，包括直接插入排序、起泡排序、直接选择排序和归并排序；（2）另一类是不稳定的，包括希尔排序、快速排序和堆排序

⑷算法简单性；

从算法简单性看，

（1）一类是简单算法，包括直接插入排序、直接选择排序和起泡排序，

（2）另一类是改进后的算法，包括希尔排序、堆排序、快速排序和归并排序这些算法都很复杂。

九、心得体会

通过这次课程设计，我收获了很多东西，老实讲，之前都没有这么系统详细的把各类排序好好整理一下。这学期的课程没有编程要求，所以这次任务给了我一个很好的锻炼机会。我认为写程序千万不能急躁，我之前总是急躁，稍微遇到

点困难就放弃不写，导致自己没有进步，遇到错误要自己一步步调试，慢慢查找原因，实在不会要肯去问别人，不要怕麻烦。总之一定要坚持编程，才能不断提高自己的能力。