程序设计课程设计报告要求

课设报告的基本要求

⒈需求分析:

陈述程序设计的任务,强调程序要做什么,明确规定:

⑴输入的形式和输入值的范围；

⑵输出的形式；

⑶程序所能达到的功能；

⑷测试数据:包括正确的输入输出结果和错误的输入及其输出结果。

⒉概要设计:

说明用到的数据类型、主程序流程及各函数之间的调用关系。

⑴本程序所用的数据类型的定义；

⑵本程序所用到的标准函数名称、自定义函数名称；

⑶主程序的流程及各函数之间的层次关系。（用图来描述）

⒊详细设计：

⑴用流程图描述每个自定义函数，并给出适当的注释。

⑵写出各函数的调用关系图。

⒋调试分析：

⑴调试过程中所遇到的问题及解决方法；

⑵经验与体会。

⒌用户使用说明：说明如何使用你的程序，详细列出每一步操作步骤。

⒍测试结果：列出对于给定的输入所产生的输出结果。

⒎附录：

提交带注释的完整源程序。

格式要求：

⑴封面：(购买)标准课程设计报告封面——；

⑵内页：(打印)纸张：16K；

边距：上——2.5CM，下——2.5CM，

左——2.5CM，右——2CM

标题：四号，黑体，加粗，左对齐.

正文：小四号，宋体，首行缩进2个字

程序代码：五号，宋体

图题：五号，宋体，居中，如：图1.1 主程序的流程图

附件四：课设文档示范文档

目录

一、需求分析 (3)

二、概要设计 (3)

三、详细设计 (5)

四、调试分析 (10)

五、用户手册 (10)

六、测试数据 (10)

七、附录 (12)

一、需求分析

要求：本节是需求分析的部分，该节主要说明课程设计题目的具体要求，如:程序应具备的功能、程序设计时必须使用的数据结构（数组、动态链表、文件等）、程序运行时对输入输出格式的要求以及对程序运行性能的要求等，在撰写本节的文档时，对于以上的具体要求应详细地给出明确的说明。

⒈用数组的基本操作完成汉若塔问题的求解，其中数组的基本操作作为一个独

立的模块存在。

⒉以二维数组M[m+2][n+2]表示汉若塔，M[i][j] 表示汉若塔中相应（i,j）位置

的通行状态，完成汉若塔的抽象数据类型。

⒊用户从屏幕上输入迷宫，完成对应迷宫的初始化。

⒋迷宫的入口位置和出口位置在合法范围内由用户而定。

⒌程序完成对迷宫路径的搜索，如果存在路径，则以长方形形式将迷宫打印出

来，用特定符号标出迷宫的物理状态，其中字符“#”表示不可行，“*”表示出口和入口，空格表示没有经过的部分，“◆”标记出可行的路径；如果程序完成搜索后没有找到通路，则提示用户“can?t find one way!”。

⒍程序执行的命令：

⑴创建初始化迷宫；

⑵搜索迷宫；

⑶输出搜索结果。

二、概要设计

要求：概要设计是在理解程序的各项需求以后，对程序的结构和模块进行设计的环节。该节主要说明的内容包括对程序中所使用数据结构的介绍（如数组、数组表示的意义、数组的名称、结构体的名称，结构体成员表示的意义，文件的名称等）、对程序中主要模块以及模块之间关系的介绍（即程序由哪些模块组成，模块之间有何种关系等），在撰写本节的文档时，对于以上的具体内容给出详尽的说明。

⒈设计栈的抽象数据类型定义：

ADT Stack {

数据对象：D={ai:|ai∈PositionSet,i=1…n,n≥0}

数据关系：R1={|ai-1,ai∈d,i=2,…n}

基本操作：操作结果

InitStack(&S) 构造一个空栈，完成栈的初始化S

DestoryStack(&S) 撤消一个已经存在的栈S

ClearStack(&S) 将栈S重新置空

StackLength(S) 返回栈的长度

GetTop(S,&e) 用e返回栈S的栈顶元素

StackEmpty(S) 若S为空返回1，否则返回0

Push(&S,e) 将新的元素e压入栈顶

Pop(&S,e) 删除栈顶元素，并用e返回其值StackTraverse(s) 将栈S的所有元素输出

}ADT Stack；

⒉迷宫的抽象数据类型定义：

ADT Maze{

数据对象：D：={aij,Start,end|aij,Start,end∈{} 0≤i≤m+2,0≤j≤n+2,m,n≥0}

数据关系：R={ROW.COL}

Row={|ai-1,aij∈D i=1,…,m+2,j=1,…,n+2}

Col={|aijaij-1∈D}

基本操作:

SetMaze(&Maze)

初始条件：Maze已经定义，Maze的下属单元二维数组Maze.M[row+2][d+2]已存在，Maze.start,Maze.end也已作为下属存储单元存在

操作结果：构成数据迷宫，用数值标识迷宫的物理状态，以0表示通路，以1表示障碍，由终端读取迷宫空间大小，各点处的具体物理状态及Start和End点位置，完成迷宫构建

Pass(&Mazem,&Nposition,Position,di)

初始条件：已知目前迷宫状态及当前位置、下一步探索方向di

操作结果：完成相应的搜索任务，如果可行，则用Nposition返回下一步位置，并将Maze状态改变为相应点已走过情况

PrintMaze(Maze)

操作结果：输出字符标示的迷宫

FindWay(Maze,&way)

操作结果：利用Pass搜索迷宫，用way返回搜索所得路径。如不存在，返回０

PrintWay(Maze,way)

操作结果：将Maze及相应最短路径一起打印输出

}ADT MAZE,

⒊本程序模块结构

⑴主函数模块

void main(){

初始化；

do{

接受命令；

处理命令；

｝while（退出命令）

｝

⑵栈模块——实现栈抽象数据类型；

⑶迷宫模块——实现迷宫抽象数据类型；

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

主程序模块

迷宫模块

栈模块

三、详细设计

要求：详细设计是在概要设计基础上对各模块进一步细化的环节。本节需要介绍的内容包括程序中所有函数的介绍（包括函数的原型，函数的功能，各参数的名称以及表示的意义）、函数之间的调用关系（见如下的例子）、程序核心模块算法的介绍（需要用流程图描述），在撰写本节的文档时，对于以上的具体内容给出详尽的说明，作图要规范，排版要统一。

⒈基本数据类型操作

⑴栈模块

① typedef struct{

int x,y,num; // X、Y坐标位置，NUM栈的追踪序号}Postype;

② typedef struct{

SelemType *base; // 在栈初始化之前和销毁之后为NULL

SelemType *top; // 栈顶指针，在栈顶元素上方一单元处

int stacksize; // 当前已分配存储空间，以元素为单位} sqstack; // 线性存储结构

③参数设置：

#define STACK_INIT_SIZE 20;

#define STACKINIREMENT 10;

//----------基本操作的算法描述--------------------

Status InitStack(SqStack &s){ // 构造一个空栈

S.base=(SelemType )malloc(STACK_INIT_SIZE*SizeOf(SelemType));

if(!S.base)exit(OVERLOW); // 存储分配失败

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

return ok;

}

Staus DestoryStack(Sqstack &s){// 销毁栈S

Free(S.base);

S.top=S.base; S.stacksize=o;

return ok;

}

Status ClearStack(sqstack &S){ // 清空S

S.top=S.base;return ok;

}

Status StackEmpty(Sqstack S){ // 若S为空返回TRUE，否则返回FALSE

return S.base==S.top;

}

int stackLength(Sqstack S) // 返回栈S的长度，以单元为单位

return S.top-S.base;

}

Status GetTop(SqStack S,Selemtype &e){

// 栈不空，用e返回s的栈顶元素及OK，否则返回ERROR

if(S.top==S.base)return ERROR;

e=*(S.top-1);

return ok;

}

Status Push(Sqstack &S,SelemType e){ // 插入元素e为新的栈顶元素

if(S.top-S.base>=S.stacksize){// 栈满追加存储空间

S.base=(SelemType)realloc(S.base,(S.stacksize+ST ACKICREMENT)Sizeof(Selemtype));

if(!S.base)exit(OVERFLOW) // 存储分配失败

S.top=S.base+S.stacksize; // 确定新的栈顶指针

S.stacksize+=STACKINCREMENT;// 已分配空间增加

}

*S.top++=e;

return ok;

}

Status Pop(Sqstack &s,SelemType &e){

// 若栈不变，则删除栈顶元素，用e返回其值及ok,否则false

if(S.top=o=S.base)

return ERROR;

e=*--S.top; // 顶指针减小，用e返回其数据

return ok;

}

⑵迷宫模块：

①迷宫的数据类型

#define MAXSIZE 50 // 屏幕宽度，迷宫的最大宽度

typeof struct{

int M[][MAXSIZE]; // 迷宫的物理状态描述

int Row,Col; // 迷宫的大小

Position Start,end; // 开始与结束位置与栈的单元类型相同

}MAZE; // “迷宫”型数据

②迷宫模块中的基本操作

Status semaze(MAZE &Maze){

Printf(“请输入所建迷宫的宽度Row和高度Col”);

Do{

sanf(“row,col”);

if(Row>MAXSIZE-2)

printf(“太大，请重新输入”);

}while(Row>MAXSIZE-2);

for(i=0;i<=Row+1;i++){ // 设置迷宫边界

Maze.M[0][i]=1;

Maze.M[Col+1][i]=1;

}

for(i=0;i<=Col+1;i++){

Maze.M[i][0]=1;

Maze.M[1][Row+1]=1;

}

for(i=1;i<=col;i++){ // 输入相应迷宫各点处的具体物理状态

for(j=1;j<=Row;i++)

scanf(“Maze.M[i][j]”);

p rintf(“\n”);

}

printf(“设置出入口”);

scanf(“Maze.start,Maz.end);

Maze.M[Maze.start.x][Maze.start.Y]=2;

Maze.M[Maze.end.x][Maze.end.Y]=2;

Maze.Row=Row;Maze.Col=Col;

}

void printMaze(MAZE Maze){ // 打印出迷宫，包括边界

for(i=0;i<=Maze.Col+1;i++)

for(j=0;j<=Maze.Row+1;j++)

printf(“%c\n”,Maze.M[i][j]); // 用字符型打印输出（i,j）状态

printf(“出口：”);

}

Status Pass(MAZE &Maze,Position Pos,Position,&N_pos,int di){

// 判断迷宫中当前位置dos在di 方向上能否通过

// 如果通过用npos返回下一步位置，并将通信位置保留入maze switch(di){

case 1:if(Maze.M[pos.x+1][pos.y]!=1){

N_posx=Posx+1;

return 1; // npos赋予位置，并将对应状态改为走过

}break;

case 2:if(Maze.M[Pos.x][Pos.y+1]!=1){

N_pos.x=pos.x;N_pos.y=Pos.y+1;

Maze.M[N_pos]=1;

return 1;

}break;

case 3: if(Maze.M[Pos.x-1][Pos.y]!=1){

N_pos.x=pos.x-1;N_pos.y=Pos.y;

Maze.M[N_pos]=1;

return 1;

}break;

case 4: if(Maze.M[Pos.x][Pos.y-1]!=1){

N_pos.x=pos.x;N_pos.y=Pos.y-1;

Maze.M[N_pos]=1;

return 1;

}break;

return 0;

}

Status FindWay(MAZE Maze,SqStack &way){

// 用pass搜索maze

// 用way 返回搜索所得路径，如果不存在返回值0

InitStack(S); // 设置工作栈

Push(S,Maze.start); // 将开始位置入栈，工作开始

P=s->base; // 搜索位置开始于start处

Do{

Pos=*p; // 持续下一步搜索，当前位置POS

For(i=1;i<=4;i++) // 四方位全面搜索

if (pass(&maze, pos &n_pos,i ){ // 如果通过对下一点（访问）

N_pos.NOM=P->(s->base); // 记下追踪序数

Push(S,N_Pos); // 将可行点如栈

}

P++; // 继续下一步

}

while((pos.x!=Maze.end.x||Maze.end.y)&&p!=s->top);

if(p==s->top)return 0; // 无路径可达

p=&Pos; // 从出口入逆向路径

do{

p=S->base+->NUM; // 由p->num找回上一步位置

Push(&way,*P);

}while(p!=s->base);Destory(&s);

}

void PrintWay(MAZE.Maze,Sqstack Way){ // 将迷宫及路径一起打印

print(“最短路径“””);

for(p=way.base;p

Maze.M[p->x][p->y]=4; // 标出路径

PrintMaze(Maze); // 打印输出

}

⑶主函数算法：

main(){

clrscr();

InitStack(&way);

Do{

Printf(“现在开始构筑迷宫”);

SetMaze(&Maze);

Printf(“所得迷宫状态为：”);

PrintMaze(Maze);

Printf(“按任意键开始搜索路径”);

Setch();printf(“搜索结果：”);

if(FindWay(Maze,&way)){

Printf(“所锝路径：”);

PrintWay(Maze,Way);

}

else

printf(“没有可到达出口处”);

printf(“按C键继续处理其它迷宫或其它键退出”);

getch(c);

}while(c==?c?||c==?C?);

destoryStack(“&Way”);

}

⒉函数的调用关系反映了本演示程序的层次结构

SetMaze

……

Push GetTop Pop StackLength StackEmpty ClearStack

四、调试分析

要求：本节为调试分析的部分，在撰写本节的文档时，应对程序调试过程中出现的问题以及如何解决的过程进行说明。说明应详尽，排版要统一。

⒈开始没有将M[n][m].start.end设置为MAZE 型数据的下属单元，使得各个迷

宫操作的函数参数十分散杂，调试时各参数关系不易把握。

⒉另行设置PrintWay函数，使得终端输出更加友好，并巧妙地将迷宫以特殊、

明朗的字符输出，效果更好。

⒊只须将FindWay程序中搜索循环的结束条件改动，并增加栈便可输出迷宫的

所有路径。追踪时还要多加一次循环对工作栈进行扫描。

五、用户手册

要求：本节需要对程序运行时的操作步骤和使用顺序做出具体的说明(如是否对路径要求，如何运行程序等)。说明应详尽，排版要统一。

⒈本程序的运行环境为DOS操作系统，执行文件为Maze.exe；

⒉进入演示程序后，即显示对话形式的提示操作过程，

如：提出开始建筑迷宫

输入迷宫的大小

输入迷宫具体结构现在的迷宫状态为：

按任意键开始搜索

搜索结果：最短路径为：\没有找到可行路径

按…C?键continue 或其它键Quit

⒊提示输入迷宫大小后，用户输入所要处理迷宫的宽ROW,高COL；

⒋提示输入迷宫后，用户将迷宫输入，0代表可行，1代表障碍；

⒌按任意键开始后，程序自动进行对所建迷宫的搜索，并将搜索结果；

⒍进行下一个迷宫处理单元或退出程序。

六、测试数据

要求：本节需要对程序调试过程中所使用的测试数据以及输入测试数据以后的结果进行说明。说明应详尽，排版要统一。

现在开始建筑迷宫(set the Maze now:

please Enterin the size of the maze your want to deal with:

The Row(<50):8 The Col:8

Enter the Maze:

0 0 1 0 0 0 1 0

0 0 1 0 0 0 1 0

0 0 0 0 1 1 0 0

0 1 1 1 0 0 0 0

0 0 0 1 0 0 0 0

0 1 0 0 0 1 0 0

0 1 1 1 0 1 1 0

1 0 0 0 0 0 0 0

Enter the Start and end please:

The start :1 1

The end: 8 8

Nowthe maze is :

完成退出

The shortest way of the maze is:””

七、附录

要求：本节可以根据实际的需要对部分主要的程序源代码进行介绍。代码要给出注释，排版要统一

⒈源程序文件清单：

栈：stack.c

迷宫：Maze.c

⒉源程序

⑴栈stack.c

#define STACK_INIT_SIZE 50

#define STACKIN[REMENT] 10

typedef struct{

intX;

int Y;

int Num;

}Position,SelemType;

typedef Sturct{

SElemType *base;

SelemType *top;

int Satcksizi;

}SqStack;

void Init Stack(SqStack &S){

Sibase=(SelemType *) malloc(STACK_INIT_SIZE *Sizeof(SelemType));

if (!Sibase) exit(OVERFLOW);

S→top=S→base;

S→StackSize=STACK_INIT_SIZE;

}

void GetTop(SqStack S,SelemType e &e){

if(S.top==S.base)

exit(-1);

e.X=*(S.top-1).x;

e.Y=*(S.top-1).Y;

e.Num=*(S.top-1).Num;

}

void Push(SqStack &s,SelemType e){

if(s.top-s.base>=s.stacksize){

S.base=(SelemType*)

realloc(S.base,(S.stacksize+STACKIN(EMENT)*SIZEOF(seLEMtYP));

if(!S.base)

exit(OVERFLOW);

S.top=S.base+S.stackSize;

S.stacksize+=STACKINCREMENT;

}

*(S.top).X=e.X;

*(S.top).Y=e.Num;

S.top++;

}

void Pop(Sqstack *s,SelemType &e){

if(S.top==S.base)

exit(-1);

e.X=*(S.top).x;

e.Y=*(S.top).y

e.NUM=*(S.top).Num

}

(2) 迷宫Maze.c：

#include "Stack.c"

#define MAXSIZE 50

typedef Sturct{

int M[][MAXSIZE];

int Row;

int Col;

Position end;

Position start;

}MAZE;

void SetMaze(MAZE &Maze){

int i,j,Row,Col;

printf("Now Set the Maze:\n");

printf("The Row of the Maze:");

Scanf("%d",&Row);

printf("The Col of the Maze:");

scanf("%d",&Col);

for(i=0;i<=Row+1;i++){

Maze.M[0][1]=1;

Maze.M[Col+1]=1;

for (i=0;i<=Col+1;i++){

Maze.M[i][0]=1;

Maze.M[Row+1][i];

}

for(i=1;i<=Col;i++){

for(j=1;j<=Row;j++)

scanf("%d",Maze.M[i][j]);

printf("\n");

}

printf("Give The Start and end of the Maze:");

scanf("%d%d",&Maze,Star x, &Maze.Star.Y);

scanf("%d%d",&Maze.end.x &Maze.end.Y) }

Maze.M[Maze.Start.X][Maze.Start.Y]=2; Maze.M[Maze.Send.X][Maze.Send.Y]=2; Maze.Row=Row;

Maze.Col=Col;

}

void printMaze(MAZE Maze){

int i,j;

for(i=0;i<=Maze.Col;i++){

for(i=0;i<=Maze.Col;i++);

printf(“%c”,Maze.M[i][j]);

printf(“\n”);

}

}

int Pass(MAZE &Maze,Position Pos,Position &n_pos,int di){ Switch(di){

case 1: if(Maze.M[pos.x+1][pos.Y]!=1){

N_pos.X=pos.X+1;N_pos.Y=pos.Y;

Maze.M[N_pos.x][N.pos.Y]=1;

return 1;

}break;

case 2: if(Maze.M[pos.X][pos.Y+1]!=1){

N_pos.X=pos.X,N_pos.Y=pos.Y+1;

Maze.M[N_pos.X][N_pos.Y]=1;

return 1;

}break;

case 3: if(Maze.M[pos.X-1][pos.Y]!=1){

N_pos.X=pos.X-1,N_pos.Y=pos.Y;

Maze.M[N_pos.X][N_pos.Y]=1;

return 1;

}break;

case 4: if(Maze.M[pos.X][pos.Y-1]!=1){

N_pos.X=pos.X,N_pos.Y=pos.Y-1;

Maze.M[N_pos.X][N_pos.Y]=1;

return 1;

}break;

}

return 0;

}

int FindWay(MAZE maze,Sq Stack &way){

int i;

Sq Stack s;

Position pos,n_pos *p;

InitStack(&s);

Push(&s,Maze.Satrt);

P=s→base;

Do{

Pos=*p;

For(i=1;i<+4;i++){

if(pass(&Maze,Pos_&N_pos,i)){

N_pos.Num=p-(s→base);

Push(&s,N_pos);

}

}

p++;

}while(pos.x!=end.x||pos.Y!end.Y)&&p!=s→top;

if(p==s→top) return 0; p=&pos;

do {

p=s→bas+p→Num;

Push(Way,*p);

}while(p!=s→base);

return 1;

}

void printway(MAZE maze,Sq Stack Way){

int v;

SelemType *p;

Printf(“-----------------The SortestWay----------------------\n”); For(p=Way.base;p

M[p→X][p→Y]=4;

print(Maze);

}

main(){

MAZE Maze;

Sq.stack Way;

Char c;

Clrcsr();

InitStack &Way;

Do{

printf(“Now is deal the Maze:\n”);

SetMaze(&Maze);

Printf(“now The Maze is like This :\n”);

}

}