完整版数据结构课程设计报告.docx

完整版数据结构课程设计报告.docx

《完整版数据结构课程设计报告.docx》由会员分享，可在线阅读，更多相关《完整版数据结构课程设计报告.docx（12页珍藏版）》请在冰豆网上搜索。

完整版数据结构课程设计报告

数据结构课程设计报告

一．前沿：

排序是数据结构中的一块难点，也是重点。

熟练的掌握各种各样的排序算法是对每个编程人员的基本的要求。

历年的考研还是期末考中，排序都占了比较大的比重。

二．程序实现的功能：

本程序采用了各种不同的方法对同一个输入进行排序，且每一个元素其本身亦是一个结构体，又可以进行扩充，使其可以存储其他的相关的信息。

在此我仅仅举了结构体本身只有一个元素的情况。

a）采用的数据类型：

为了讨论的方便，本程序采用了复合型的结构体类型，且才用了静态线性表的形式，不能进行扩充，一旦空间开辟，就不能在扩充（注意）。

具体如下：

typedefstruct{//每个元素的类型定义，为了讨论的方便本程序采用了单关键字；

intkey;//但可以根据需要扩充，每个关键字令其为整型的；

}redtype;

typedefstruct{//开辟的数组，以上述类型的元素组成；

redtype*r;//存入要输入的元素的数组；

intlength;//数组的长度，shellsort中要用到；

}sqlist;

四．对部分头文件和函数的说明：

：

改头文件主要用来实现清屏，使得出的结果更清晰明白。

“shellsort（sqlistl,intd）”：

该函数主要实现希尔排序，使无序的数据排列成有序的序列

“quicksort（sqlistl,intlow,inthigh）”：

该函数实现的功能同上，只是原理不同

“heapadjust（sqlistl,ints,intm）”：

该函数实现调整无序的数据序列使其成为

大顶堆，即树型结构的最上面是值最大的，这样进过一次的调整便得到了值

最大的元素，即可进过多次的排序使一个无序的序列又序。

“heapsort（sqlistl）”：

该函数实现建立堆的过程。

在其中间调用heapadjust实现

最终建立大顶的任务。

“oesort（sqlistl,intn）”：

该函数进行奇偶排序将无序的数据排成有序的。

五．核心程序算法：

voidshellsort（sqlist&l,intd）

{//采用希尔排序，本程序中的l.r[0].key使暂存单元，非哨兵。

d=l.length/2;

while（d>0）

{

for（i=d+1;i<=l.length;++i）

if（l.r[i].key

{

l.r[0]=l.r[i];

for（j=i-d;j>0&&l.r[0].key

l.r[j+d]=l.r[j];

l.r[j+d]=l.r[0];}

d=d/2;}

}

基本思想：

先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。

所有距离为dl的倍数的记录放在同一个组中。

先在各组内进行直接插人排序；然后，取第二个增量d2

该方法实质上是一种分组插入方法

voidquicksort（sqlist&l,intlow,inthigh）

{//快速排序

if（low

{i=low;j=high;l.r[0]=l.r[i];

do{

while（il.r[0].key）

--j;

if（i

{l.r[i]=l.r[j];++i;}

while（i

++i;

if（i

l.r[j]=l.r[i];--j;

}

}while（i!

=j）;

l.r[i]=l.r[0];

quicksort（l,low,i-1）;对r[low..i-1]进行快速排序

quicksort（l,i+1,high）;对r[I+1.high]进行快速排序

}}

基本思想

设当前待排序的无序区为r[low..high]，利用分治法可将快速排序的基本思想描述为：

①分解：

在r[low..high]中任选一个记录作为基准（Pivot），以此基准将当前无序区划分为左、右两个较小的子区间r[low..pivotpos-1]和r[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录（不妨记为pivot）的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置（pivotpos）上，它无须参加后续的排序。

 注意：

划分的关键是要求出基准记录所在的位置pivotpos。

划分的结果可以简单地表示为（注pivot=r[pivotpos]）r[low..pivotpos-1].keys≤r[pivotpos].key≤r[pivotpos+1..high].keys  其中low≤pivotpos≤high。

②求解：

通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和r[pivotpos+1..high]快速排序。

③组合：

因为当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序。

对快速排序而言，"组合"步骤无须做什么，可看作是空操作。

voidheapadjust（sqlist&l,ints,intm）

{///筛选法调整堆，使其成为大顶堆　　　

rc=l.r[s].key;

for（j=2*s;j<=m;j*=2）

{if（j

j++;

if（rc>l.r[j].key）break;

l.r[s].key=l.r[j].key;

s=j;}

l.r[s].key=rc;}

voidheapsort（sqlist&l）

{//建堆的过程

for（i=l.length/2;i>0;i--）

heapadjust（l,i,l.length）;

for（i=l.length;i>1;i--）

{t=l.r[1].key,l.r[1].key=l.r[i].key,l.r[i].key=t;

heapadjust（l,1,i-1）;

}}

基本思想：

堆排序利用了大根堆堆顶记录的关键字最大这一特征，使得在当前无序区中选取最大关键字的记录变得简单。

先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区。

再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录r[n]交换，由此得到新的无序区r[1..n-1]和有序区r[n]，且满足r[1..n-1].keys≤r[n].key。

由于交换后新的根R[1]可能违反堆性质，故应将当前无序区r[1..n-1]调整为堆。

然后再次将r[1..n-1]中关键字最大的记录r[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区r[1..n-2]和有序区r[n-1..n]，且仍满足关系r[1..n-2].keys≤r[n-1..n].keys，同样要将r[1..n-2]调整为堆。

直到无序区只有一个元素为止。

voidoesort（sqlist&l,intn）

{//奇偶交换排序

change=1;标志变量，若其为零，即两次更替的交换中都没有交换数据，即排序结束

while（change）

{

change=0;

for（i=1;i

if（l.r[i].key>l.r[i+1].key）

{

t=l.r[i].key,l.r[i].key=l.r[i+1].key,l.r[i+1].key=t;

change=1;

}

for（i=2;i

if（l.r[i].key>l.r[i+1].key）

{

t=l.r[i].key,l.r[i].key=l.r[i+1].key,l.r[i+1].key=t;

change=1;

}}}

算法过程：

①第一趟对序列中的所有奇数项i扫描，

②第二趟对序列中的所有偶数项i扫描。

若ri]>r[i+1]，则交换它们。

③第三趟有对所有的奇数项，第四趟对所有的偶数项，……

④如此反复，直到整个序列全部排好序为止。

五．源程序：

#include"stdio.h"

#include"malloc.h"

#include"conio.h"

#definemaxsize5

typedefstruct{

intkey;

}redtype;

typedefstruct{

redtype*r;

intlength;

}sqlist;

voidshellsort（sqlistl,intd）

{

inti,j;

d=l.length/2;

while（d>0）

{

for（i=d+1;i<=l.length;++i）

if（l.r[i].key

{

l.r[0]=l.r[i];

for（j=i-d;j>0&&l.r[0].key

l.r[j+d]=l.r[j];

l.r[j+d]=l.r[0];}

d=d/2;}

}

voidquicksort（sqlistl,intlow,inthigh）

{inti,j;

if（low

{i=low;j=high;l.r[0]=l.r[i];

do

{

while（il.r[0].key）

--j;

if（i

{l.r[i]=l.r[j];++i;}

while（i

++i;

if（i

l.r[j]=l.r[i];--j;

}

}while（i!

=j）;

l.r[i]=l.r[0];

quicksort（l,low,i-1）;

quicksort（l,i+1,high）;

}

}

voidheapadjust（sqlistl,ints,intm）

{

intrc,j;

rc=l.r[s].key;

for（j=2*s;j<=m;j*=2）

{

if（j

j++;

if（rc>l.r[j].key）

break;

l.r[s].key=l.r[j].key;

s=j;

}

l.r[s].key=rc;

}

;voidheapsort（sqlistl）

{

inti,t;

for（i=l.length/2;i>0;i--）

heapadjust（l,i,l.length）;

for（i=l.length;i>1;i--）

{

t=l.r[1].key,l.r[1].key=l.r[i].key,l.r[i].key=t;

heapadjust（l,1,i-1）;

}

}

voidoesort（sqlistl,intn）

{

intt,i,change;

change=1;

while（change）

{

change=0;

for（i=1;i

if（l.r[i].key>l.r[i+1].key）

{

t=l.r[i].key,l.r[i].key=l.r[i+1].key,l.r[i+1].key=t;

change=1;

}

for（i=2;i

if（l.r[i].key>l.r[i+1].key）