《数据结构课程设计报告》的书写规范及示例.docx

《数据结构课程设计报告》的书写规范及示例.docx

《《数据结构课程设计报告》的书写规范及示例.docx》由会员分享，可在线阅读，更多相关《《数据结构课程设计报告》的书写规范及示例.docx（20页珍藏版）》请在冰豆网上搜索。

《数据结构课程设计报告》的书写规范及示例

《数据结构课程设计报告》的书写规范

对于每一个应用程序所解决的问题，都应有规范说明的文档。

书写合格的文档和编程调试同等重要，是合格软件必不可少的文献。

本课程设计采用的规范说明格式如下：

题目：

一、问题描述

1、题目内容

2、基本要求

3、测试数据

二、需求分析

1、（程序所能达到的基本功能）

2、（输入的形式和输入值的范围）

3、（输出的形式）

4、（测试数据要求）

三、概要设计

1、（所需的ADT，它们的作用）

2、（主程序流程及模块调用关系）

3、（核心的粗线条伪码算法）

四、详细设计

1、（实现概要设计的数据类型，重点语句加注释）

2、（每个操作的伪码算法，重点语句加注释）

3、（主程序和其他模块的伪码算法，重点语句加注释）

4、（函数调用关系图）

五、调试分析

1、（设计与调试过程中遇到的问题及分析、体会）

2、（主要和典型算法的时空复杂度的分析）

六、使用说明

（简要说明程序运行操作步骤）

七、测试结果

（包括输入输出，输入集应多于需求分析的数据）

八、附录（带注释的源程序）

其中，问题描述旨在建立问题提出的背景环境，指明问题的求解的要求。

需求分析以无歧义的方式陈述说明程序设计的任务和功能。

概要设计说明程序中用到的所有抽象数据类型的定义、主程序流程和模块之间的层次关系。

详细设计实现概要设计中定义所有数据类型，对每个操作和核心模块写出伪码算法，画出函数的调用关系图。

调试分析主要记载调试过程、经验体会，并进行算法的时空分析。

使用说明讲述操作步骤和运行环境。

测试结果应包括运行的各种数据集和所有的输入输出情况。

附录主要指源程序代码和下达任务的其他原始文件。

数据结构课程设计报告示例

数据结构课程设计报告

题目：

编制完成集合的交、并、差运算的程序

专业年级：

姓名：

学号：

12345

指导老师：

杨先凤、游书涛完成日期：

2012年1月6日成绩：

一、问题描述

1、题目内容：

利用有序链表表示正整数集合，实现集合的交、并和差运算。

2、基本要求：

由用户输入两组整数分别作为两个集合的元素，由程序计算它们的交、并、差集，并将运算结果输出。

3、测试数据：

S1={3，5，6，9，12，27，35}

S2={5，8，10，12，27，31，42，51，55，63}

运行结果应为：

S1∪S2={3,5,6,8,9,10,12,27,31,35,42,51,55,63}

S1∩S2={5,12,27}

S1-S2={3,6,9,35}

二、需求分析：

由于集合的操作主要限于求并、交和差，因此在本课程设计中以有序表表示集合，但进一步将集合本身设计成抽象数据类型，以便以后可以在集合类型的操作基础上，构造高一层次的算法，以便完成更复杂的应用。

1、本程序用以求出任意两个同类型数据的集合的交、并和差集。

2、程序运行后显现提示信息，由用户输入两组同类型的数。

程序将自动滤去输入的重复整数及负数。

3、用户输入数据完毕，程序将输出运算结果。

4、测试数据应为两组正整数，范围最好在0—35000之间。

三、概要设计

为实现程序功能，以有序链表表示集合。

为此建立有序表和集合两个抽象数据类型。

1、有序表的抽象数据类型定义为：

ADTOrderList{

数据对象：

D={ai|ai∈ElemSet,i=1,2,……,n,n≥0}

数据关系：

R1={|ai-1,ai∈D,i=2,……,n}

基本操作：

InitList（&L）

操作结果：

构造一个空的有序表L。

DestroyList（&L）

初始条件：

有序表L已存在。

操作结果：

销毁有序表L。

ListEmpty（L）

初始条件：

有序表L已存在。

操作结果：

若L为空表，则返回TRUE,否则返回FALSE。

ListLength（L）

初始条件：

有序表L已存在。

操作结果：

返回L中数据元素个数。

GetElem（L,i）

初始条件：

有序表L已存在,并且1≤i≤ListLength（L）。

操作结果：

返回L中第i数据个元素的值。

LocatePos（L,e）

初始条件：

有序表L已存在,e为和有序中元素同类型的值。

操作结果：

若有序表L中已存在和值e相同的元素，则返回它在有序表中的序号；否则返回0；

InsertElem（&L,e）

初始条件：

有序表L已存在。

操作结果：

在L中按有序关系插入值和e相同的数据元素。

DeleteElem（&L,i,）

初始条件：

有序表L已存在。

操作结果：

删除有序表L中第i个数据元素。

ListTraverse（L,visit（））

初始条件：

有序表L已存在。

操作结果：

依次对L的每个数据元素调用函数visit（）。

一旦visit（）失败，则操作失败。

}ADTOrderedList

2、集合的抽象数据类型定义为：

ADTSet{

数据对象：

D={ai|ai∈ElemSet且ai互不相同,i=1,2,……,n,n≥0}

数据关系：

R1={}

基本操作：

CrtNullSet（&T）

操作结果：

构造一个空集T。

DestroySet（&T）

初始条件：

集合T已存在。

操作结果：

销毁集合T。

AddElem（&T,e）

初始条件：

集合T已存在。

操作结果：

若集合T中不含和e相同的元素，则添加元素e，否则空操作。

DelElem（&T,e）

初始条件：

集合T已存在。

操作结果：

若集合T中存在元素e，则从T中删除该元素，否则空操作。

Union（&T,S1,S2）

初始条件：

集合S1和S2已存在。

操作结果：

生成一个由S1和S2的并集构成的集合T。

Intersection（&T,S1,S2）

初始条件：

集合S1和S2已存在。

操作结果：

生成一个由S1和S2的交集构成的集合T。

Difference（&T,S1,S2）

初始条件：

集合S1和S2已存在。

操作结果：

生成一个由S1和S2的差集构成的集合T。

PrintSet（T）

初始条件:

集合T已存在。

操作结果：

输出集合T中全部元素。

}ADTSet

3、本程序由三个模块完成，

1、主程序模块：

用以接受命令和处理命令，完成集合的交、并和差运算。

2、集合单元模块；实现集合的抽象数据类型。

3、有序表单元模块：

实现有序表的抽象数据类型。

各模块单元之间的调用关系如下：

四、详细设计

1、元素类型、结点类型和指针类型。

typedefintElemType;//元素类型

typedefstructNodeType{

ElemTypedata;

NodeType*next;

}NodeType,*LinkType;//结点类型和指针类型

2、有序表类型。

typedefstruct{

LinkTypehead,tail;//分别指向有序链表的头结点和尾结点

intsize;//链表当前的长度

intcurpos;//当前被操作的元素在有序表中的位置

LinkTypecurrent;//当前指针，指向链表中第curpos个元素

}OrderedList;//有序链表类型

3、公用的常量和类型声明：

（Common．H源程序清单如下）

#include

#include

#include

#include

#include

#defineTRUE1

#defineFALSE0

#defineOK1

#defineERROR0

#defineINFEASIBLE-1

#defineOVERFLOW-2

#defineMAXINT30000

typedefintstatus;

4、有序链表实现单元（OrderdList.H源程序清单如下）

typedefintElemType;

typedefstructNodeType{

ElemTypedata;

NodeType*next;

}NodeType,*LinkType;//结点类型和指针类型

typedefstruct{

LinkTypehead,tail;//分别指向有序链表的头结点和尾结点

intsize;//链表当前的长度

intcurpos;//当前被操作的元素在有序表中的位置

LinkTypecurrent;//当前指针，指向链表中第curpos个元素

}OrderedList;//有序链表类型

statusInitList（OrderedList&L）

{

//构造一个带头结点的空的有序链表L，并返回TRUE

//若分配空间失败，则令L.head为NULL，并返回FALSE

L.head=newNodeType;

if（!

L.head）returnFALSE;

L.head->data=0;//头结点的数据域暂虚设元素为0

L.head->next=NULL;

L.current=L.tail=L.head;

L.curpos=L.size=0;

returnTRUE;

}//InitList

voidDestroyList（OrderedList&L）

{

//销毁链表

LinkTypep;

while（L.head->next）{

p=L.head->next;

L.head->next=p->next;

deletep;

}//while

deleteL.head;

}//DestroyList

ElemTypeGetElem（OrderedListL,inti）

{

//若1≤i≤ListLength（L），则返回L中第i个元素，否则返回MAXINT

//MAXINT为予设常量，其值大于有序表中所有元素

if（（i<1）||（i>L.size））

returnMAXINT;

if（i==L.curpos）

returnL.current->data;

if（i

L.curpos=0;L.current=L.head;

}

else{

L.curpos++;L.current=L.current->next;

}

while（L.curpos

L.curpos++;L.current=L.current->next;

}

returnL.current->data;

}//GetElem

intLocatePos（OrderedList&L,ElemTypee）

{

//若有序表L中已存在值和e相同的元素，则返回它在有序表中的序号；

//否则返回0，此时L.current指示插入位置，即插在它之后

if（!

L.head）return0;//有序表不存在

if（e==L.current->data）returnL.curpos;

if（edata）{

L.current=L.head;

L.curpos=0;

}

if（L.head->next&&e==L.head->next->data）return1;

while（L.current->next&&（e>L.current->next->data））{

L.current=L.current->next;

L.curpos++;

}

if（（!

L.current->next）||（enext->data））return0;

elsereturnL.curpos;

}//LocatePos

voidInsertElem（OrderedList&L,ElemTypee）

{

//若有序表L中不存在其值和e相同的元素，则按有序关系插入之，

//否则空操作。

插入之后，当前指针指向新插入的结点

LinkTypes;

if（!

LocatePos（L,e））{

s=newNodeType;s->data=e;

s->next=L.current->next;

L.current->next=s;

if（L.tail==L.current）L.tail=s;

L.current=s;

L.curpos++;

L.size++;

}//if

}//InsertElem

voidDeleteElem（OrderedList&L,inti）

{

//若1≤i≤ListLength（L），则删除有序表L中第i个数据元素，否则空操作

intpre;

LinkTypeq;

if（（i>=1）&&（i<=L.size））{

pre=GetElem（L,i-1）;

q=L.current->next;

L.current->next=q->next;//删除第i个元素

if（L.tail==q）

L.tail=L.current;

deleteq;//释放结点空间

L.size--;

}//if

}//DeleteElem

voidoutput（LinkTypep）

{

//作为被visit导入的指针函数

cout<data<<",";

}//output

voidListTraverse（OrderedList&L,void（*visit）（LinkType））

{

//依次对L的每个结点元素调用函数visit（）

LinkTypep;

if（L.head）{

p=L.head->next;

while（p）{visit（p）;p=p->next;}

}

}//ListTraverse

5、有序集实现单元：

（OrderedSet．H源程序清单如下）

typedefOrderedListOrderedSet;

statusCrtNullSet（OrderedSet&T）

{

//构造一个空集T

if（InitList（T））//构造空集T

returnTRUE;

elsereturnFALSE;

}//CrtNullSet

voidDestroySet（OrderedSet&T）

{

//销毁集合T的结构

DestroyList（T）;

}//DestroyList

voidAddElem（OrderedSet&T,ElemTypee）

{

//若集合T中不含和e相同的元素，则添加元素e，否则空操作

if（e>0）

InsertElem（T,e）;

}//AddElem

voidDelElem（OrderedSet&T,ElemTypee）

{

//若集合T中含和e相同的元素，则删除之，否则空操作

ElemTypek;

if（k=LocatePos（T,e））

DeleteElem（T,k）;

}//DelElem

intSetLength（OrderedSetT）

{

//求集合元素的个数

returnT.size;

}

voidUnion（OrderedSet&T,OrderedSetS1,OrderedSetS2）

{

//求集合S1和S2的并集T

intia,ib;

ElemTypea,b;

if（InitList（T））{//构造空的结果集T并开始求并集

ia=1;ib=1;//ia和ib分别指示S1和S2中元素序号

while（（ia<=SetLength（S1））||（ib<=SetLength（S2）））

{//S1或S2尚有元素

a=GetElem（S1,ia）;b=GetElem（S2,ib）;

//a和b为两集合中进行比较的当前元素

if（a<=b）{//处理a<=b的情况

InsertElem（T,a）;//在T中插入一个其值和a相同的元素

ia++;

if（a==b）ib++;

}//if

else{//处理b

InsertElem（T,b）;//在T中插入一个其值和b相同的元素

ib++;

}//else

}//while

}//if

}//Union

voidIntersection（OrderedSet&T,OrderedSetS1,OrderedSetS2）

{

//求集合S1和S2的交集T

intia,ib;

ElemTypea,b;

if（InitList（T））{//构造空的结果集T并开始求交集

ia=1;ib=1;//ia和ib分别指示S1和S2中元素序号

while（（ia<=SetLength（S1））&&（ib<=SetLength（S2）））{

a=GetElem（S1,ia）;b=GetElem（S2,ib）;

//a和b为两集合中进行比较的当前元素

if（a

elseif（a>b）ib++;

else{//处理a=b的情况

InsertElem（T,a）;//在T中插入一个其值和a相同的元素

ia++;ib++;

}//else

}//while

}//if

}//Intersection

voidDifference（OrderedSet&T,OrderedSetS1,OrderedSetS2）

{

//求集合S1和S2的差集T

intia,ib;

ElemTypea,b;

if（InitList（T））{//构造空的结果集T并开始求差集

ia=1;ib=1;//ia和ib分别指示La和Lb中元素序号

while（（ia<=SetLength（S1））||（ib<=SetLength（S2）））{//S1或S2尚有元素

a=GetElem（S1,ia）;b=GetElem（S2,ib）;

//a和b为两集合中进行比较的当前元素

if（b<=a）{//处理b<=a的情况

ib++;

if（a==b）ia++;

}//if

else{//处理a

InsertElem（T,a）;//在T中插入一个其值和a相同的元素

ia++;

}//else

}//while

}//if

}//Difference

voidCreateSet（OrderedSet&ST）

{

//通过输入元素的数据，构建一个集合

ElemTypeelem;

CrtNullSet（ST）;

cin>>elem;

while（elem!

=-1）{

AddElem（ST,elem）;

cin>>elem;

}//while

}//CreateSet

voidPrintSet（OrderedSetT）

{

//输出集合的全部元素

cout<

ListTraverse（T,output）;

cout<<"}";

}//PrintSet

6、主程序模块（Set．Cpp源程序清单如下）

#include"common.h"

#include"orderlist.h"

#include"orderset.h"

voidmain（）{

OrderedSetS1,S2,T1,T2,T3;

cout<

";//构造集合S1

CreateSet（S1）;

cout<

";//构造集合S2

CreateSet（S2）;

PrintSet（S1）;

PrintSet（S2）;//显示集合S1及S2

Union（T1,S1,S2）;//对集合作并、交、差运算，显示结果

cout<

";

PrintSet（T1）;

Intersection（T2,S1,S2）;

cout<

";

PrintSet（T2）;

Difference（T3,S1,S2）;

cout<

";

PrintSet（T3）;

DestroySet（T1）;//销毁各集合

DestroySet（T2）;

DestroySet（T3）;

DestroySet（S1）;

DestroySet（S2）;

cout<

}

五、调试分析

1、程序中将指针的操作封装在链表的类型中，在集合的类型模块中，只须引用链表的操作实现相应的集合运算即可，从而使集合模块的调试比较方便。

2、算法的时空分析：

（1）由于有序表采用带头结点的有序单链表，并增设尾指针和表的长度两个标识，各种操作的算法时间复杂度比较合理，LocatePos,GetElem及DestroyList等操作的时间复杂度均为O（n），其中n为链表长度。

（2）构造有序集算法CreateSet读入n个元素，逐个用LocatePos判定输入元素不在当前集合确定插入位置后，采用InsertElem插入到当前并集中，从表面上看，其时间复杂度为O（m*n），但由于“插入”是按元素值由小到大的次序进行，m+n次LocatePos操作的时间复杂度为O（m+n），这充分体现了在链表的定义中设置当前指针current和当前位置curpos的优越性。

因此，算法Union的时间复杂度为O（m+n）。

可作类似分析，求交集算法Intersection和求差集算法Difference的时间复杂度也是O（m+n）。

销毁集合算法DestroySet和输出集合运算的算法PrintSet都是对每个元素调用一个O

（1）的函数，因此都是O（n）d.

除了构造有序集算法CreateSet用一个ElemType类型变量elem读入元素，需要O

（1）的辅助空间外，其余算法使用的辅助空间也与元素个数