中南大学
课程设计报告
题目数据结构课程设计学生姓名
指导教师漆华妹
学院信息科学与工程学院专业班级
学号
完成时间 2011年07月
目录
第一章、需求分析 (2)
第二章、概要设计 (2)
2.1设定图的抽象数据类型 (2)
2.2设定队列的抽象数据类型 (3)
2.3本程序包含的功能模块 (3)
第三章、详细设计 (3)
3.1顶点、边和图的类型 (6)
3.2队列类型 (8)
3.3主程序和其他伪码算法 (9)
第四章、调试分析 (9)
第五章、用户手册 (9)
第六章、测试结果 (10)
第七章、心得体会 (10)
附：源程序代码 (11)
图遍历的演示
题目:试设计一个程序,演示在连通的无向图上访问全部结点的操作
第一章、需求分析
1、以邻接多重表为存储结构；
2、实现连通和非连通的无向图的深度优先和广度优先遍历；
3、要求利用栈实现无向图的深度优先遍历；
4、以用户指定的结点为起点,分别输出每种遍历下的结点访问序列和生成树的边集；
5、用凹入表打印生成树；
6、求出从一个结点到另外一个结点，但不经过另外一个指定结点的所有简单路径；6、本程序用C语言编写，在C-Free3.5环境下通过。
第二章、概要设计
1、设定图的抽象数据类型:
ADT Graph{
数据对象V:V是具有相同特性的数据元素的集合,称为点集.
数据关系R:
R={VR}
VR={(v,w)|v,w属于V,(v,w)表示v和w之间存在的路径} 基本操作P:
CreatGraph(&G,V,VR)
初始条件:V是图的顶点集,VR是图中弧的集合.
操作结果:按V和VR是定义构造图G.
DestroyGraph(&G)
初始条件:图G存在
操作结果:销毁图G
LocateVex(G,u)
初始条件: 图G存在,u和G中顶点有相同的特征
操作结果:若图G中存在顶点u,则返回该顶点在图中的位置;否则返回其他信息GetVex(G,v)
初始条件: 图G存在,v是G中顶点
操作结果:返回v的值
FirstAjvex(G,v)
初始条件: 图G存在,v是G中顶点
操作结果:返回v的第一个邻接顶点,若顶在图中没有邻接顶点,则返回为空
NextAjvex(G,v,w)
初始条件: 图G存在,v是G中顶点,w是v的邻接顶点
操作结果:返回v的下一个邻接顶点,若w是v的最后一个邻接顶点,则返回空DeleteVexx(&G,v)
初始条件: 图G存在,v是G中顶点
操作结果:删除顶点v已经其相关的弧
DFSTraverse(G,visit())
初始条件: 图G存在,visit的顶点的应用函数
操作结果: 对图进行深度优先遍历,在遍历过程中对每个结点调用visit函数一
次,一旦visit失败,则操作失败
BFSTraverse(G,visit())
初始条件: 图G存在,visit的顶点的应用函数
操作结果:对图进行广度优先遍历,在遍历过程中对每个结点调用visit函数一次,一旦visit失败,则操作失败
}ADT Graph
2、设定队列的抽象数据类型：
ADT Queue{
数据对象:D={ai|ai属于Elemset,i=1,2….,n,n>=0}
数据关系:R1={
约定ai为端为队列头,an为队列尾
基本操作:
InitQueue(&Q)
操作结果:构造一个空队列Q
DestryoQueue(&Q)
初始条件：队列Q已存在。
操作结果：队列Q被销毁，不再存在。
EnQueue(&Q,e)
初始条件:队列Q已经存在
操作结果:插入元素e为Q的新的队尾元素
DeQueue(&Q,&E)
初始条件:Q为非空队列
操作结果:删除Q的队尾元素,并用e返回其值
QueueEmpty(Q)
初始条件:队列已经存在
操作结果:若队列为空,则返回TRUE,否则返回FLASE
}ADT Queue
3、本程序包含四个模块：
1）主程序模块
void main ()
{
手动构造一个图；
进行深度优先遍历图；
进行广度优先遍历图；
}；
2）手动构造一个图-自己输入图的顶点和边生成一个图；
3）进行深度优先遍历图-打出遍历的结点序列和边集；
4）进行广度优先遍历图-打出遍历的结点序列和边集；
第三章、详细设计
1、顶点,边和图类型
#define MAX_INFO 10 /* 相关信息字符串的最大长度+1 */
#define MAX_VERTEX_NUM 20 /* 图中顶点数的最大值*/
int visited[MAX_VERTEX_NUM]; /*全局变量，访问标志数组 */
typedef char InfoType; /*相关信息类型*/
typedef char VertexType; /* 字符类型 */
typedef enum{unvisited,visited}VisitIf;
typedef struct EBox /*边结点类型*/
{
int mark; /*访问标记 */
int ivex,jvex; /*该边依附的两个顶点位置*/
struct EBox *ilink,*jlink; /*分别指向依附这两个顶点的下一条边 */
}EBox;
typedef struct VexBox /*顶点结点类型*/
{
char data[MAX_LEN];
EBox *fistedge; /*指向第一条依附该顶点的边*/
}VexBox;
typedef struct
{
VexBox list[MAX_VERTEX_NUM];
int vexnum,edgenum; /*无向图当前顶点数和边数 */
}AMLGraph;
图的基本操作如下：
int LocateVex(AMLGraph G,VertexType u)；
//查G和u有相同特征的顶点，若存在则返回该顶点在无向图中位置;否则返回-1。VertexType& GetVex(AMLGraph G,int v)；
//以v返回邻接多重表中序号为i的顶点。
int FirstAdjVex(AMLGraph G,VertexType v)；
//返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1。
int NextAdjVex(AMLGraph G,VertexType v,VertexType w)；
//返回v的(相对于w的)下一个邻接顶点的序号若w是v的最后一个邻接点,则返回-1。void CreateGraph(AMLGraph &G)；
//采用邻接多重表存储结构,构造无向图G。
Status DeleteArc(AMLGraph &G,VertexType v,VertexType w)；
//在G中删除边
Status DeleteVex(AMLGraph &G,VertexType v)；
//在G中删除顶点v及其相关的边。
void DestroyGraph(AMLGraph &G)；
//销毁一个图
void Display(AMLGraph G)；
//输出无向图的邻接多重表G。
void DFSTraverse(AMLGraph G,VertexType start,int(*visit)(VertexType))；
//从start顶点起,（利用栈非递归）深度优先遍历图G。
void BFSTraverse(AMLGraph G,VertexType start,int(*Visit)(VertexType))；
//从start顶点起,广度优先遍历图G。
void MarkUnvizited(AMLGraph G)；
//置边的访问标记为未被访问。
其中部分操作的算法如下：
void CreateGraph(AMLGraph *p) /*创建无向图 */ {
int i,j,k;
EBox *q;
printf("\n\t\t\t请输入图的结点个数和边的个数:");
/*输入图的结点数和边数*/
scanf("%d,%d",&p->vexnum,&p->edgenum);
for(i=1;i<=p->vexnum;i++)
{ printf("\n\t\t\t请输入结点%d的名称:",i);/*输入顶点数据信息*/
scanf("%s",p->list[i].data);
p->list[i].fistedge=NULL; /*初始化指针*/ }
for(k=0;k
scanf("%d,%d",&i,&j);
q=(EBox *)malloc(sizeof(EBox));
q->mark=0; /*对边结点赋值*/
q->ivex=i;
q->ilink=p->list[i].fistedge;
q->jvex=j;
q->jlink=p->list[j].fistedge;
p->list[i].fistedge=p->list[j].fistedge=q; /*完成边在链头的插入*/
}
printf("\n");
}
void DFS(AMLGraph *p, int v)
{ /*对第v个顶点的深度优先遍历 */
int w;
EBox *q;
visited[v]=1; /*标记已访问结点 */
printf("%s ",p->list[v].data);
for(q=p->list[v].fistedge;q!=NULL;)
{if(q->ivex==v)
{w=q->jvex; q=q->jlink;}
else
{w=q->ivex; q=q->ilink;}
if(!visited[w]) DFS(p,w); /*对尚未访问的点调用DFS*/
}
}
void DFSTraverse(AMLGraph *p,int n)
{ /*深度优先遍历 */
int v;
printf("\n\t\t\t");
for(v=1;v<=p->vexnum;v++)
visited[v]=0; *访问标志数组初始化*/ DFS(p,n); /*对起始顶点调用DFS*/ for(v=1;v<=p->vexnum;v++)
if(!visited[v]) DFS(p,v); /*对尚未访问的顶点调用DFS*/
printf("\n");
}
2、队列类型
typedef int QelemType；
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
QueuePtr front;
QueuePtr rear; /* 队头、队尾指针 */
}LinkQueue;
队列的基本操作如下：
Status InitQueue(LinkQueue &Q)；
//构造一个空队列Q。
Status DestroyQueue(LinkQueue &Q)；
//销毁队列Q(无论空否均可)。
Status QueueEmpty(LinkQueue Q)；
//若Q为空队列,则返回1,否则返回-1。
Status EnQueue(LinkQueue &Q,QElemType e)；
//插入元素e为Q的新的队尾元素。
Status DeQueue(LinkQueue &Q,QElemType &e)；
//若队列不空,删除Q的队头元素,用e返回其值,并返回1,否则返回-1。
其中部分操作的算法如下：
void BFS(AMLGraph *p,int v)
{ /*对第v个顶点进行广度优先遍历*/
int u,w;
EBox *x;
typedef struct queue
{
int m;
struct queue *next;
}Q; /*辅助队列Q*/
Q *head,*tail,*q;
head=tail=(Q *)malloc(sizeof(Q));
tail->next=NULL;
visited[v]=1; /*标记已访问结点 */
printf("%s ",p->list[v].data);
tail->m=v; /*v入队列 */
tail->next=(Q *)malloc(sizeof(Q));
tail=tail->next;
tail->next=NULL;
while(head!=tail)
{
q=head;
head=head->next;
u=q->m; /*对头元素出队并置为u*/ free(q);
for(x=p->list[u].fistedge;x!=NULL;)
{ if(x->ivex==u) {w=x->jvex;x=x->ilink;}
else {w=x->ivex;x=x->jlink;}
if(!visited[w])
{
visited[w]=1;
printf("%s ",p->list[w].data);
tail->m=w; /*w入队列*/
tail=tail->next=(Q *)malloc(sizeof(Q));
tail->next=NULL;
} /*if*/
} /*for */
} /*while*/
} /*BFS*/
void BFSTraverse(AMLGraph *p,int n)
{ printf("\n\t\t\t"); /*广度优先遍历*/
int v;
for(v=1;v<=p->vexnum;v++)
visited[v]=0; /*访问标志数组初始化*/ BFS(p,n); /*对起始顶点调用BFS*/ for(v=1;v<=p->vexnum;v++)
if(!visited[v]) BFS(p,v);
printf("\n"); /*对未访问顶点调用BFS*/
}
3、主程序和其他伪码算法
void main ()
{
显示菜单；
输入功能选择键；
switch(flag)
{
case 1:手动构造一个图；
case 2:进行深度优先遍历图；
case 3:进行广度优先遍历图；
case 4:退出程序；
}
算法代码
main() /*主函数 */
{ int x,n;
AMLGraph graph,*p;
p=&graph;
system("color 1f");
printf("\t\t\t****** 图的深度和广度优先遍历 *******\n"); printf("\t\t\t* *\n"); printf("\t\t\t****** ********\n");
printf("\n");
while(1)
{ printf("\n");
printf("\t\t\t ~~~~~~~~ 功能菜单 ~~~~~~~ \n"); printf("\n");
printf("\t\t\t*********************************************\n");
printf("\t\t\t* 1.创建图 *\n");
printf("\t\t\t* *\n");
printf("\t\t\t* 2.深度优先遍历图 *\n");
printf("\t\t\t* *\n");
printf("\t\t\t* 3.广度优先遍历图 *\n");
printf("\t\t\t* *\n");
printf("\t\t\t* 4.退出系统 *\n");
printf("\t\t\t* *\n");
printf("\t\t\t*********************************************\n");
printf("\n\t\t\t请输入选择的功能编号（1-4）：");
scanf("%d",&n);
if(n<0 || n>4)
{
printf("\n\n\t\t\t你输入的功能号错误，请重新输入，按Enter键继续！！");
getchar();
getchar();
continue;
}
switch(n)
{
case 1: system("color 3f");
CreateGraph(p);break;
case 2: { system("color 79");
printf("\n\t\t\t请输入起始遍历结点:");
scanf("%d",&x);
printf("\n\t\t\t深度优先遍历结果为:");
printf("\n");
DFSTraverse(p,x);
printf("\n");
} break;
case 3: { system("color 2E");
printf("\n\t\t\t请输入起始遍历结点:");
scanf("%d",&x);
printf("\n\t\t\t广度优先遍历结果为:");
printf("\n");
BFSTraverse(p,x);
printf("\n");
} break;
case 4: printf("\n\n\t\t\t谢谢你的使用！\n\n\n");
exit(0);
}/*switch */
} /*while */
} /*main */
第四章、调试分析
1、本程序以邻接多重表为存储结构。这个程序涉及到图的生成和图的深度以及广度遍历,文件的保存和读取，还有栈和队列的操作，另外还有森林的生成和打印，路径的寻找。
2、本程序不仅可以进行连通无向图的遍历，还可以进行非连通图的遍历。为了方便显示和理解，现在暂且用一个大写字母表示一个顶点。边还可以附加信息，但为了方便操作，暂且不输入信息。已经先把图的相关信息保存在了文本文档里，所以要测试时直接从文件导入，可以减少用手输入的麻烦，同时也可以减少输入的错误。
3、由于构造图时，后输入的边是插在先输入的边的前面。所以在输入边时，可以按字母从大到小的顺序输入。那么显示图的时候就可以按字母从小到大的顺序显示。
4、程序定义了一个二倍顶点长的数组存放输入的边，以便程序可以把它保存到文件里。故
耗费了一定的内存空间。
第五章、用户手册
1、本程序的运行环境DOS操作系统，GTraverse.exe
2、进入演示程序后即显示一个有功能选择的界面，如下：
3、选择操作1：程序就提示分别输入无向图的顶点数，边数，边的信息，顶点和边的值：输入完成后，返回菜单。
4、选择操作2：系统提示输入遍历图的起始点，程序运行后，首先显示深度优先遍历的访问结点序列。
5、选择操作3：系统提示输入遍历图的起始点，程序运行后，首先显示广度优先遍历的访问结点序列。
6、选择操作4：退出程序。
第六章、测试结果
1、数据可以任意输入,但是顶点数不要太多，不然占用太多内存，会导致死机。
2、遍历一个连通的无向图，如遍历以下这个连通无向图：
A B
C D
1)选择操作1，分别进行以下操作:
请输入图的结点个数和边的个数:4,5
请输入结点1的名称:A
请输入结点2的名称:B
请输入结点3的名称:C
请输入结点4的名称:D
请输入互相有关联的两个结点:1,2
请输入互相有关联的两个结点:1,3
请输入互相有关联的两个结点:1,4
请输入互相有关联的两个结点:2,4
请输入互相有关联的两个结点:3,4
2) 选择操作2，输出图的信息如下：
请输入起始遍历结点:1
深度优先遍历结果为:A B D C
3) 选择操作3，输出图的信息如下：
请输入起始遍历结点:1
广度优先遍历结果为:A B C D
第七章、心得体会
这道题的完成，花了一个星期时间，因为我一个多学期没接触C语言和数据结构首先我把基
本功能完成后来逐步地增加了许多功能。把本来只能遍历连通图的功能上，改进为可以遍历
非连通图。通过这道设计题,使我更深刻的理解数据结构及其重要作用,对数据结构有了一个
新的认识,深刻的认识到数据结构对于我们学习计算机的重要性和其深远但是意义.同时,通
过这次课程设计,也加强我的动手能力和思维能力,可以将自己所学的知识用于实践,这不仅
对自己是一次锻炼机会,而且让自己有一种成就感和自豪感，觉得自己终于可以做出一点有
用的东西了。不过,我觉得自己编写程序的一些思路算法和水平还非常有限。所以以后自己
还得在C语言和其他语言上下苦功夫。
附：源程序
#include
#include
#define MAX_VERTEX_NUM 30 /*无向图最大顶点数*/
#define MAX_LEN 20 /*数据最大长度 */
int visited[MAX_VERTEX_NUM]; /*全局变量，访问标志数组 */ typedef struct EBox /*边结点类型*/
{
int mark; /*访问标记 */
int ivex,jvex; /*该边依附的两个顶点位置*/
struct EBox *ilink,*jlink; /*分别指向依附这两个顶点的下一条
边 */
}EBox;
typedef struct VexBox /*顶点结点类型*/
{
char data[MAX_LEN];
EBox *fistedge; /*指向第一条依附该顶点的边*/ }VexBox;
typedef struct
{
VexBox list[MAX_VERTEX_NUM];
int vexnum,edgenum; /*无向图当前顶点数和边数 */ }AMLGraph;
void CreateGraph(AMLGraph *p) /*创建无向图 */
{
int i,j,k;
EBox *q;
printf("\n\t\t\t请输入图的结点个数和边的个数:"); /*输入图的结点数和边数
*/
scanf("%d,%d",&p->vexnum,&p->edgenum);
for(i=1;i<=p->vexnum;i++)
{ printf("\n\t\t\t请输入结点%d的名称:",i); /*输入顶点数据信息*/ scanf("%s",p->list[i].data);
p->list[i].fistedge=NULL; /*初始化指针*/
}
for(k=0;k
scanf("%d,%d",&i,&j);
q=(EBox *)malloc(sizeof(EBox));
q->mark=0; /*对边结点赋值*/
q->ivex=i;
q->ilink=p->list[i].fistedge;
q->jvex=j;
q->jlink=p->list[j].fistedge;
p->list[i].fistedge=p->list[j].fistedge=q; /*完成边在链头的插入*/ }
printf("\n");
}
void DFS(AMLGraph *p, int v)
{ /*对第v个顶点的深度优先遍历 */
int w;
EBox *q;
visited[v]=1; /*标记已访问结点 */
printf("%s ",p->list[v].data);
for(q=p->list[v].fistedge;q!=NULL;)
{if(q->ivex==v)
{w=q->jvex; q=q->jlink;}
else
{w=q->ivex; q=q->ilink;}
if(!visited[w]) DFS(p,w); /*对尚未访问的点调用DFS*/
}
}
void DFSTraverse(AMLGraph *p,int n)
{ /*深度优先遍历 */
int v;
printf("\n\t\t\t");
for(v=1;v<=p->vexnum;v++)
visited[v]=0; /*访问标志数组初始化*/
DFS(p,n); /*对起始顶点调用DFS*/
for(v=1;v<=p->vexnum;v++)
if(!visited[v]) DFS(p,v); /*对尚未访问的顶点调用DFS*/
printf("\n");
}
void BFS(AMLGraph *p,int v)
{ /*对第v个顶点进行广度优先遍历*/
int u,w;
EBox *x;
typedef struct queue
{
int m;
struct queue *next;
}Q; /*辅助队列Q*/
Q *head,*tail,*q;
head=tail=(Q *)malloc(sizeof(Q));
tail->next=NULL;
visited[v]=1; /*标记已访问结点 */
printf("%s ",p->list[v].data);
tail->m=v; /*v入队列 */
tail->next=(Q *)malloc(sizeof(Q));
tail=tail->next;
tail->next=NULL;
while(head!=tail)
{
q=head;
head=head->next;
u=q->m; /*对头元素出队并置为u*/ free(q);
for(x=p->list[u].fistedge;x!=NULL;)
{ if(x->ivex==u) {w=x->jvex;x=x->ilink;}
else {w=x->ivex;x=x->jlink;}
if(!visited[w])
{
visited[w]=1;
printf("%s ",p->list[w].data);
tail->m=w; /*w入队列*/
tail=tail->next=(Q *)malloc(sizeof(Q));
tail->next=NULL;
} /*if*/
} /*for */
} /*while*/
} /*BFS*/
void BFSTraverse(AMLGraph *p,int n)
{ printf("\n\t\t\t"); /*广度优先遍历*/
int v;
for(v=1;v<=p->vexnum;v++)
visited[v]=0; /*访问标志数组初始化*/
BFS(p,n); /*对起始顶点调用BFS*/
for(v=1;v<=p->vexnum;v++)
if(!visited[v]) BFS(p,v);
printf("\n"); /*对未访问顶点调用BFS*/
}
main() /*主函数 */
{ int x,n;
AMLGraph graph,*p;
p=&graph;
system("color 1f");
printf("\t\t\t****** 图的深度和广度优先遍历 *******\n");
printf("\t\t\t* *\n");
printf("\t\t\t****** ********\n");
printf("\n");
while(1)
{ printf("\n");
printf("\t\t\t ~~~~~~~~ 功能菜单 ~~~~~~~ \n");
printf("\n");
printf("\t\t\t*********************************************\n");
printf("\t\t\t* 1.创建图 *\n");
printf("\t\t\t* *\n");
printf("\t\t\t* 2.深度优先遍历图 *\n");
printf("\t\t\t* *\n");
printf("\t\t\t* 3.广度优先遍历图 *\n");
printf("\t\t\t* *\n");
printf("\t\t\t* 4.退出系统 *\n");
printf("\t\t\t* *\n");
printf("\t\t\t*********************************************\n");
printf("\n\t\t\t请输入选择的功能编号（1-4）：");
scanf("%d",&n);
if(n<0 || n>4)
{
printf("\n\n\t\t\t你输入的功能号错误，请重新输入，按Enter键继续！！");
getchar();
getchar();
continue;
}
switch(n)
{
case 1: system("color 3f");
CreateGraph(p);break;
case 2: { system("color 79");
printf("\n\t\t\t请输入起始遍历结点:");
scanf("%d",&x);
printf("\n\t\t\t深度优先遍历结果为:");
printf("\n");
DFSTraverse(p,x);
printf("\n");
} break;
case 3: { system("color 2E");
printf("\n\t\t\t请输入起始遍历结点:");
scanf("%d",&x);
printf("\n\t\t\t广度优先遍历结果为:");
printf("\n");
BFSTraverse(p,x);
printf("\n");
} break;
case 4: printf("\n\n\t\t\t谢谢你的使用！\n\n\n");
exit(0);
}/*switch */
} /*while */
} /*main */
数学与计算机学院 课程设计说明书 课程名称: 数据结构与算法课程设计 课程代码: 6014389 题目: 图的遍历和生成树求解实现 年级/专业/班: 学生姓名: 学号: 开始时间: 2012 年 12 月 09 日 完成时间: 2012 年 12 月 26 日 课程设计成绩： 指导教师签名：年月日
目录 摘要 (3) 引言 (4) 1 需求分析 (5) 1.1任务与分析 (5) 1.2测试数据 (5) 2 概要设计 (5) 2.1 ADT描述 (5) 2.2程序模块结构 (7) 软件结构设计： (7) 2.3各功能模块 (7) 3 详细设计 (8) 3.1结构体定义 (19) 3.2 初始化 (22) 3.3 插入操作（四号黑体） (22) 4 调试分析 (22) 5 用户使用说明 (23) 6 测试结果 (24) 结论 (26)
摘要 《数据结构》课程主要介绍最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论。进行数据结构课程设计要达到以下目的： ?了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力； ?初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能； ?提高综合运用所学的理论知识和方法独立分析和解决问题的能力； 训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。 这次课程设计我们主要是应用以前学习的数据结构与面向对象程序设计知识，结合起来才完成了这个程序。 因为图是一种较线形表和树更为复杂的数据结构。在线形表中，数据元素之间仅有线性关系，每个元素只有一个直接前驱和一个直接后继，并且在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。因此，本程序是采用邻接矩阵、邻接表、十字链表等多种结构存储来实现对图的存储。采用邻接矩阵即为数组表示法，邻接表和十字链表都是图的一种链式存储结构。对图的遍历分别采用了广度优先遍历和深度优先遍历。 关键词：计算机；图；算法。
1.一元稀疏多项式计算器 [问题描述] 设计一个一元稀疏多项式简单计算器。 [基本要求] 输入并建立多项式； 输出多项式，输出形式为整数序列：n, c1, e1, c2, e2,……, cn, en ，其中n是多项式的项数，ci, ei分别是第i项的系数和指数，序列按指数降序排序； 多项式a和b相加，建立多项式a+b; 多项式a和b相减，建立多项式a-b; [测试数据] (2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7) (6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2-x2+7.8x15)=(-7.8x15-1.2x9-x+12x-3) (1+x+x2+x3+x4+x5)+(-x3-x4)=(x5+x2+x+1) (x+x3)+(-x-x3)=0 (x+x2+x3)+0=(x3+x2+x) [实现提示] 用带头结点的单链表存储多项式，多项式的项数存放在头结点中。 2.背包问题的求解 [问题描述] 假设有一个能装入总体积为T的背包和n件体积分别为w1, w2, …,wn的物品，能否从n件物品中挑选若干件恰好装满背包，即使w1+w2+…+wn=T，要求找出所有满足上述条件的解。例如：当T=10，各件物品的体积为{1，8，4，3，5，2}时，可找到下列4组解：（1，4，3，2）、（1，4，5）、（8，2）、（3，5，2） [实现提示] 可利用回溯法的设计思想来解决背包问题。首先，将物品排成一列，然后顺序选取物品转入背包，假设已选取了前i件物品之后背包还没有装满，则继续选取第i+1件物品，若该件物品“太大”不能装入，则弃之而继续选取下一件，直至背包装满为止。但如果在剩余的物品中找不到合适的物品以填满背包，则说明“刚刚”装入背包的那件物品“不合适”，应将它取出“弃之一边”，继续再从“它之后”的物品中选取，如此重复，直至求得满足条件的解，或者无解。 由于回溯求解的规则是“后进先出”因此自然要用到栈。 3.完全二叉树判断 用一个二叉链表存储的二叉树，判断其是否是完全二叉树。 4.最小生成树求解（1人） 任意创建一个图，利用克鲁斯卡尔算法，求出该图的最小生成树。 5.最小生成树求解（1人） 任意创建一个图，利用普里姆算法，求出该图的最小生成树。 6.树状显示二叉树 编写函数displaytree(二叉树的根指针，数据值宽度，屏幕的宽度)输出树的直观示意图。输出的二叉树是垂直打印的，同层的节点在同一行上。 [问题描述] 假设数据宽度datawidth=2,而屏幕宽度screenwidth为64=26,假设节点的输出位置用 （层号，须打印的空格数）来界定。 第0层：根在（0，32）处输出；
《数据结构I》三级项目报告 大连东软信息学院 电子工程系 ××××年××月
三级项目报告注意事项 1. 按照项目要求书写项目报告，条理清晰，数据准确； 2. 项目报告严禁抄袭，如发现抄袭的情况，则抄袭者与被抄袭者均 以0分计； 3. 课程结束后报告上交教师，并进行考核与存档。 三级项目报告格式规范 1. 正文：宋体，小四号，首行缩进2字符，1.5倍行距，段前段后 各0行； 2. 图表：居中，图名用五号字，中文用宋体，英文用“Times New Roman”，位于图表下方，须全文统一。
目录 一项目设计方案 (3) 二项目设计分析 (4) 三项目设计成果 (4) 四项目创新创业 (5) 五项目展望 (6) 附录一：项目成员 (6) 附录二：相关代码、电路图等 (6)
一项目设计方案 1、项目名称: 垃圾回收 2、项目要求及系统基本功能： 1）利用数据结构的知识独立完成一个应用系统设计 2）程序正常运行，能够实现基本的数据增加、删除、修改、查询等功能3）体现程序实现算法复杂度优化 4）体现程序的健壮性 二项目设计分析 1、系统预期实现基本功能： （结合本系统预期具体实现，描述出对应基本要求(增、删、改、查等)的具体功能） 1. 2. 3. 4. 5. 6. 7. 2、项目模块功能描述 （基本分为组织实施组织、程序功能模块编写、系统说明撰写等。其中程序功能子模块实现） 模块一： 主要任务：XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 模块二： 主要任务：XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 模块n： 主要任务：XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
数据结构实验报告 实验：图的遍历 一、实验目的： 1、理解并掌握图的逻辑结构和物理结构——邻接矩阵、邻接表 2、掌握图的构造方法 3、掌握图的邻接矩阵、邻接表存储方式下基本操作的实现算法 4、掌握图的深度优先遍历和广度优先原理 二、实验内容： 1、输入顶点数、边数、每个顶点的值以及每一条边的信息，构造一个无向图G，并用邻接矩阵存储改图。 2、输入顶点数、边数、每个顶点的值以及每一条边的信息，构造一个无向图G，并用邻接表存储该图 3、深度优先遍历第一步中构造的图G，输出得到的节点序列 4、广度优先遍历第一部中构造的图G，输出得到的节点序列 三、实验要求： 1、无向图中的相关信息要从终端以正确的方式输入； 2、具体的输入和输出格式不限； 3、算法要具有较好的健壮性，对错误操作要做适当处理； 4、程序算法作简短的文字注释。 四、程序实现及结果： 1、邻接矩阵： #include
课程设计说明书 课程名称：数据结构 专业：班级： 姓名：学号： 指导教师：成绩： 完成日期：年月日
任务书 题目：黑白棋系统 设计内容及要求： 1.课程设计任务内容 通过玩家与电脑双方的交替下棋，在一个8行8列的方格中，进行棋子的相互交替翻转。反复循环下棋，最后让双方的棋子填满整个方格。再根据循环遍历方格程序，判断玩家与电脑双方的棋子数。进行大小判断，最红给出胜负的一方。并根据y/n选项，判断是否要进行下一局的游戏。 2.课程设计要求 实现黑白两色棋子的对峙 开发环境：vc++6.0 实现目标： （1）熟悉的运用c语言程序编写代码。 （2）能够理清整个程序的运行过程并绘画流程图 （3）了解如何定义局部变量和整体变量； （4）学会上机调试程序，发现问题，并解决 （5）学习使用C++程序来了解游戏原理。 （6）学习用文档书写程序说明
摘要 本文的研究工作在于利用计算机模拟人脑进行下黑白棋，计算机下棋是人工智能领域中的一个研究热点，多年以来，随着计算机技术和人工智能技术的不断发展，计算机下棋的水平得到了长足的进步 该程序的最终胜负是由棋盘上岗双方的棋子的个数来判断的，多的一方为胜，少的一方为负。所以该程序主要运用的战术有削弱对手行动战术、四角优先战术、在游戏开局和中局时，程序采用削弱对手行动力战术，即尽量减少对手能够落子的位置；在游戏终局时则采用最大贪吃战术，即尽可能多的吃掉对手的棋子；而四角优先战术则是贯穿游戏的始终，棋盘的四角围稳定角，不会被对手吃掉，所以这里是兵家的必争之地，在阻止对手进角的同时，自己却又要努力的进角。 关键词：黑白棋；编程；设计
《数据结构与算法》课程设计报告 学号： 班级序号： 姓名： 指导教师： 成绩： 中国地质大学信息工程学院地理信息系统系 2011年12 月
1．需求规格说明 【问题描述】 利用哈夫曼编码进行对已有文件进行重新编码可以大大提高减小文件大小，减少存储空间。但是，这要求在首先对一个现有文件进行编码行成新的文件，也就是压缩。在文件使用时，再对压缩文件进行解压缩，也就是译码，复原原有文件。试为完成此功能，写一个压缩/解压缩软件。 【基本要求】 一个完整的系统应具有以下功能： （1）压缩准备。读取指定被压缩文件，对文件进行分析，建立哈夫曼树，并给出分析结果（包括数据集大小，每个数据的权值，压缩前后文件的大小），在屏幕上输出。 （2）压缩。利用已建好的哈夫曼树，对文件进行编码，并将哈夫曼编码及文件编码后的数据一起写入文件中，形成压缩文件(*.Haf)。 （3）解压缩。打开已有压缩文件(*.Haf)，读取其中的哈夫曼编码，构建哈夫曼树，读取其中的数据，进行译码后，写入文件，完成解压缩。 （4）程序使用命令行方式运行 压缩命令：SZip A Test.Haf 1.doc 解压缩命令：SZip X Test.Haf 2.doc或SZip X Test.Haf 用户输入的命令不正确时，给出提示。 （5）使用面向对象的思想编程，压缩/解压缩、哈夫曼构建功能分别构建类实现。 2．总体分析与设计 （1）设计思想： 1、压缩准备：1> 读文件，逐个读取字符，统计频率 2> 建立哈夫曼树 3> 获得哈弗曼编码 2、压缩过程： 1> 建立一个新文件，将储存权值和字符的对象数组取存储在文件头
数据结构实验---图的储存与遍历
学号： 姓名： 实验日期： 2016.1.7 实验名称： 图的存贮与遍历 一、实验目的 掌握图这种复杂的非线性结构的邻接矩阵和邻接表的存储表示，以及在此两种常用存储方式下深度优先遍历(DFS)和广度优先遍历(BFS)操作的实现。 二、实验内容与实验步骤 题目1：对以邻接矩阵为存储结构的图进行DFS 和BFS 遍历 问题描述：以邻接矩阵为图的存储结构，实现图的DFS 和BFS 遍历。 基本要求：建立一个图的邻接矩阵表示，输出顶点的一种DFS 和BFS 序列。 测试数据：如图所示 题目2：对以邻接表为存储结构的图进行DFS 和BFS 遍历 问题描述：以邻接表为图的存储结构，实现图的DFS 和BFS 遍历。 基本要求：建立一个图的邻接表存贮，输出顶点的一种DFS 和BFS 序列。 测试数据：如图所示 V0 V1 V2 V3 V4 三、附录： 在此贴上调试好的程序。 #include
#define M 100 typedef struct node { char vex[M][2]; int edge[M ][ M ]; int n,e; }Graph; int visited[M]; Graph *Create_Graph() { Graph *GA; int i,j,k,w; GA=(Graph*)malloc(sizeof(Graph)); printf ("请输入矩阵的顶点数和边数(用逗号隔开)：\n"); scanf("%d,%d",&GA->n,&GA->e); printf ("请输入矩阵顶点信息：\n"); for(i = 0;i
#include"stdlib.h" #include"stdio.h" #include"malloc.h" #define INFINITY 32767 #define MAX_VERTEX_NUM 20 typedef enum{FALSE,TRUE}visited_hc; typedef enum{DG,DN,UDG,UDN}graphkind_hc; typedef struct arccell_hc {int adj; int*info; }arccell_hc,adjmatrix_hc[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; typedef struct {char vexs[MAX_VERTEX_NUM]; adjmatrix_hc arcs; int vexnum,arcnum; graphkind_hc kind; }mgraph_hc; typedef struct arcnode_hc {int adjvex; struct arcnode_hc *nextarc; int*info; }arcnode_hc; typedef struct vnode_hc {char data; arcnode_hc *firstarc; }vnode_hc,adjlist_hc[MAX_VERTEX_NUM]; typedef struct {adjlist_hc vertices; int vexnum,arcnum; graphkind_hc kind; }algraph_hc; int locatevex_hc(mgraph_hc*g,char v) {int i,k=0; for(i=0;i
《数据结构课程设计》报告 题目：课程设计题目2教学计划编制 班级：700 学号：09070026 姓名：尹煜 完成日期：2011年11月7日
一．需求分析 本课设的任务是根据课程之间的先后的顺序，利用拓扑排序算法，设计出教学计划，在七个学期中合理安排所需修的所有课程。 （一）输入形式：文件 文件中存储课程信息，包括课程名称、课程属性、课程学分以及课程之间先修关系。 格式：第一行给出课程数量。大于等于0的整形，无上限。 之后每行按如下格式“高等数学公共基础必修6.0”将每门课程的具体信息存入文件。 课程基本信息存储完毕后，接着给出各门课程之间的关系，把每门课程看成顶点，则关系即为边。 先给出边的数量。大于等于0的整形。 默认课程编号从0开始依次增加。之后每行按如下格式“1 3”存储。此例即为编号为1的课程与编号为3的课程之间有一条边，而1为3的前驱，即修完1课程才能修3课程。 例： （二）输出形式：1.以图形方式显示有向无环图
2.以文本文件形式存储课程安排 （三）课设的功能 1.根据文本文件中存储的课程信息（课程名称、课程属性、课程学分、课程之间关系） 以图形方式输出课程的有向无环图。 拓展：其显示的有向无环图可进行拖拽、拉伸、修改课程名称等操作。 2.对课程进行拓扑排序。 3.根据拓扑排序结果以及课程的学分安排七个学期的课程。 4.安排好的教学计划可以按图形方式显示也可存储在文本文件里供用户查看。 5.点击信息菜单项可显示本人的学好及姓名“09070026 尹煜” （四）测试数据（见六测设结果）
二．概要设计 数据类型的定义： 1.Class Graph即图类采用邻接矩阵的存储结构。类中定义两个二维数组int[][] matrix 和Object[][] adjMat。第一个用来标记两个顶点之间是否有边，为画图服务。第二个 是为了实现核心算法拓扑排序。 2.ArrayList
编号 课程设计 题目 1、一元稀疏多项式计算器 2、模拟浏览器操作程序 3、背包问题的求解 4、八皇后问题 二级学院计算机科学与工程学院 专业计算机科学与技术 班级 2011级 37-3班 学生姓名 XX 学号 XXXXXXXXXX 指导教师 XXXXX 评阅教师 时间 1、一元稀疏多项式计算器 【实验内容】 一元稀疏多项式计算器。
【问题描述】 设计一个一元稀疏多项式简单计算器。 【需求分析】 其基本功能包括： （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列为：n,c1,e1,c2,e2,……,cn,en,其中n 是多项式的项数，ci，ei分别是第i项的系数和指数，序列按指数降序排序；（3）多项式a和b相减，建立多项a+b； （4）多项式a和b相减，建立多项式a-b； （5）计算多项式在x处的值； （6）计算器的仿真界面（选做）； 【概要设计】 -=ADT=- { void input(Jd *ha,Jd *hb)； void sort(dnode *h)
dnode *operate(dnode *a,dnode *b) float qiuzhi(int x,dnode *h) f",sum); printf("\n"); } 【运行结果及分析】 （1）输入多项式：
（2）输出多项式（多项式格式为：c1x^e1+c2x^e2+…+cnx^en）： （3）实现多项式a和b相加： （4）实现多项式a和b相减： （5）计算多项式在x处的值：
2、模拟浏览器操作程序 【实验内容】 模拟浏览器操作程序 【问题描述】 标准Web浏览器具有在最近访问的网页间后退和前进的功能。实现这些功能的一个方法是：使用两个栈，追踪可以后退和前进而能够到达的网页。在本题中，要求模拟实现这一功能。 【需求分析】 需要支持以下指令： BACK：将当前页推到“前进栈”的顶部。取出“后退栈”中顶端的页面，使它成为当前页。若“后退栈”是空的，忽略该命令。 FORWARD：将当前页推到“后退栈”的顶部。取出“前进栈”中顶部的页面，使它成为当前页。如果“前进栈”是空的，忽略该命令。 VISIT
##大学 数据结构课程设计报告题目：图的遍历和生成树求解 院（系）：计算机工程学院 学生: 班级：学号: 起迄日期: 2011.6.20 指导教师:
2010—2011年度第 2 学期 一、需求分析 1.问题描述： 图的遍历和生成树求解实现 图是一种较线性表和树更为复杂的数据结构。在线性表中，数据元素之间仅有线性关系，每个数据元素只有一个直接前驱和一个直接后继；在树形结构中，数据元素之间有着明显的层次关系，并且每一层上的数据元素可能和下一层中多个元素（及其孩子结点）相关但只能和上一层中一个元素（即双亲结点）相关；而在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。 生成树求解主要利用普利姆和克雷斯特算法求解最小生成树，只有强连通图才有生成树。 2.基本功能 1) 先任意创建一个图； 2) 图的DFS,BFS的递归和非递归算法的实现 3) 最小生成树（两个算法）的实现，求连通分量的实现 4) 要求用邻接矩阵、邻接表等多种结构存储实现 3.输入输出
输入数据类型为整型和字符型，输出为整型和字符 二、概要设计 1.设计思路： a.图的邻接矩阵存储：根据所建无向图的结点数n,建立n*n的矩阵，其中元素全是无穷大（int_max），再将边的信息存到数组中。其中无权图的边用1表示，无边用0表示；有全图的边为权值表示，无边用∞表示。 b.图的邻接表存储：将信息通过邻接矩阵转换到邻接表中，即将邻接矩阵的每一行都转成链表的形式将有边的结点进行存储。 c.图的广度优先遍历：假设从图中的某个顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后再访问此邻接点的未被访问的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中还有未被访问的，则另选未被访问的重复以上步骤，是一个非递归过程。 d.图的深度优先遍历：假设从图中某顶点v出发，依依次访问v的邻接顶点，然后再继续访问这个邻接点的系一个邻接点，如此重复，直至所有的点都被访问，这是个递归的过程。 e.图的连通分量：这是对一个非强连通图的遍历，从多个结点出发进行搜索，而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其连通分量的顶点集。本程序利用的图的深度优先遍历算法。 2.数据结构设计： ADT Queue{ 数据对象：D={a i | a i ∈ElemSet,i=1,2,3……，n,n≥0} 数据关系：R1={| a i-1 ,a i ∈D,i=1,2,3,……，n} 基本操作： InitQueue(&Q) 操作结果：构造一个空队列Q。 QueueEmpty(Q) 初始条件：Q为非空队列。 操作结果：若Q为空队列，则返回真，否则为假。 EnQueue(&Q,e) 初始条件：Q为非空队列。 操作结果：插入元素e为Q的新的队尾元素。 DeQueue(&Q,e) 初始条件：Q为非空队列。 操作结果：删除Q的队头元素，并用e返回其值。}ADT Queue
《数据结构》 课程设计报告 学号 姓名 班级 指导教师 安徽工业大学计算机学院 2010年6月
建立二叉树和线索二叉树 1.问题描述： 分别用以下方法建立二叉树并用图形显示出来： 1）用先序遍历的输入序列 2）用层次遍历的输入序列 3）用先序和中序遍历的结果 2.设计思路： 分三个方式去实现这个程序的功能，第一个实现先序遍历的输入数列建立二叉树；第二个是用层次遍历的方法输入序列；第三个是用先序和后序遍历的结果来建立二叉树；三种方法建立二叉树后都进行输出。关键是将这三个实现功能的函数写出来就行了；最后对所建立的二叉树进行中序线索化，并对此线索树进行中序遍历（不使用栈）。 3.数据结构设计： 该程序的主要目的就是建立二叉树和线索二叉树，所以采用树的存储方式更能完成这个程序； 结点的结构如下： typedef struct bnode { DataType data; int ltag,rtag; struct bnode *lchild, *rchild; } Bnode, *BTree; 4.功能函数设计： BTree CreateBinTree() 用先序遍历的方法讲二叉树建立； BTree CREATREE() 用队列实现层次二叉树的创建； void CreatBT()； 用先序和中序遍历的结果建立二叉树； void InThread(BTree t,BTree pre) 中序线索化； 5.编码实现： #include
数据结构课程设计 设计说明书 TSP 问题 起止日期：2016 年 6 月27 日至2016 年7 月 1 日 学生姓名 班级 学号 成绩 指导教师( 签字) 2016 年7 月 1 日
目录 第1 章需求分析.................................................................................1... 1.1 简介 (1) 1.2 系统的开发背景 (1) 1.3 研究现状 (1) 第2 章概要设计.................................................................................2... 2.1 系统开发环境和技术介绍 (2) 2.2 系统需求分析 (2) 2.2.1 总体功能分析 (2) 2.2.2 核心功能分析 (3) 第3 章详细设计...................................................................................4... 3.1 系统开发流程 (4) 3.2 系统模块设计 (4) 3.3 系统结构 (6) 3.2 系统流程图 (6) 第4 章调试分析...................................................................................7... 4.1 程序逻辑调试 (7) 4.2 系统界面调试 (8) 第5 章测试结果...................................................................................9... 5.1 测试环境 (9) 5.2 输入输出测试项目 (9) 5.3 测试结果 (10) 结论.....................................................................................................1..1.. 参考文献................................................................................................1..1. 附录.......................................................................................................1..2..
实验项目名称：图的遍历 一、实验目的 应用所学的知识分析问题、解决问题，学会用建立图并对其进行遍历，提高实际编程能力及程序调试能力。 二、实验容 问题描述：建立有向图，并用深度优先搜索和广度优先搜素。输入图中节点的个数和边的个数，能够打印出用邻接表或邻接矩阵表示的图的储存结构。 三、实验仪器与设备 计算机，Code::Blocks。 四、实验原理 用邻接表存储一个图，递归方法深度搜索和用队列进行广度搜索，并输出遍历的结果。 五、实验程序及结果 #define INFINITY 10000 /*无穷大*/ #define MAX_VERTEX_NUM 40 #define MAX 40 #include
typedef struct ArCell{ int adj; }ArCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; typedef struct { char name[20]; }infotype; typedef struct { infotype vexs[MAX_VERTEX_NUM]; AdjMatrix arcs; int vexnum,arcnum; }MGraph; int LocateVex(MGraph *G,char* v) { int c = -1,i; for(i=0;i
实验四图的存储、遍历与应用姓名：班级： 学号：日期：一、实验目的： 二、实验内容： 三、基本思想，原理和算法描述:
四、源程序： （1）邻接矩阵的存储： #include
一、高校社团管理 在高校中，为了丰富学生的业余生活，在学校的帮助下，会成立许多社团，少则几个，多则几十个。为了有效管理这些社团，要求编写程序实现以下功能：1．社团招收新成员； 2．修改社团相应信息 3．老成员离开社团 4．查询社团情况； 5．统计社团成员数； 二、简单文本编辑器 设计一个文本编辑器，允许将文件读到内存中，也就是存储在一个缓冲区中。这个缓冲区将作为一个类的内嵌对象实现。缓冲区中的每行文本是一个字符串，将每行存储在一个双向链表的结点中，要求设计在缓冲区中的行上执行操作和在单个行中的字符上执行字符串操作的编辑命令。 基本要求： 包含如下命令列。可用大写或小写字母输入。 R：读取文本文件到缓冲区中，缓冲区中以前的任何内容将丢失，当前行是文件的第一行； W：将缓冲区的内容写入文本文件，当前行或缓冲区均不改变。 I：插入单个新行，用户必须在恰当的提示符的响应中键入新行并提供其行号。 D：删除当前行并移到下一行； F：可以从第1行开始或从当前行开始，查找包含有用户请求的目标串的第一行； C：将用户请求的字符串修改成用户请求的替换文本，可选择是仅在当前行中有效的还是对全文有效的。 Q：退出编辑器，立即结束； H：显示解释所有命令的帮助消息，程序也接受？作为H的替代者。 N：当前行移到下一行，也就是移到缓冲区的下一行； P：当前行移到上一行，也就是移到缓冲区的上一行；
B：当前行移到开始处，也就是移到缓冲区的第一行； E：当前行移到结束处，也就是移到缓冲区的最后一行； G：当前行移到缓冲区中用户指定的行； V：查看缓冲区的全部内容，打印到终端上。 三、电话客户服务模拟 一个模拟时钟提供接听电话服务的时间(以分钟计),然后这个时钟将循环的 自增1(分钟)直到达到指定时间为止。在时钟的每个"时刻"，就会执行一次检查来看看对当前电话服务是否已经完成了,如果是,这个电话从电话队列中删除,模 拟服务将从队列中取出下一个电话(如果有的话)继续开始。同时还需要执行一个检查来判断是否有一个新的电话到达。如果是,其到达时间被记录下来,并为其产生一个随机服务时间,这个服务时间也被记录下来,然后这个电话被放入电话队列中,当客户人员空闲时,按照先来先服务的方式处理这个队列。当时钟到达指定时间时,不会再接听新电话,但是服务将继续,直到队列中所偶电话都得到处理为止。 基本要求： （1）程序需要的初始数据包括：客户服务人员的人数，时间限制，电话的到达速率，平均服务时间 （2）程序产生的结果包括：处理的电话数，每个电话的平均等待时间 四、停车场管理 设停车场是一个可停放n辆车的狭长通道，且只有一个大门可供汽车进出。在停车场内，汽车按到达的先后次序，由北向南依次排列（假设大门在最南端）。若停车场内已停满n辆车，则后来的汽车需在门外的便道上等候，当有车开走时，便道上的第一辆车即可开入。当停车场内某辆车要离开时，在它之后进入的车辆必须先退出停车场为它让路，待该辆车开出大门后，其他车辆再按原次序返回车场。每辆车离开停车场时，应按其停留时间的交费（从进入便道开始计时）。在这里假设汽车从便道上开走时不收取任何费用 基本要求： （1）汽车的输入信息格式为（到达/离去的标识，汽车牌照号码，到达/离去的时间）
武汉理工大学华夏学院课程设计报告书 课程名称：数据结构课程设计 题目：用C语言实现成绩统计程序的设计系名：信息工程系 专业班级：计算机1121 姓名：吴涛 学号：10210412104 指导教师:司晓梅 2016年3 月20日
武汉理工大学华夏学院信息工程系 课程设计任务书 课程名称：数据结构课程设计指导教师：司晓梅班级名称：计算机1121 开课系、教研室：信息系计算机 一、课程设计目的与任务 《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。目的：学习数据结构课程，旨在使学生学会分析研究数据对象的特性，学会数据的组织方法，以便选择合适的数据的逻辑结构和存储结构以及相应操作，把现实世界中的问题转换为计算机内部的表示和处理，这就是一个良好的程序设计技能训练的过程。提高学生的程序设计能力、掌握基本知识、基本技能，提高算法设计质量与程序设计素质的培养就是本门课程的课程设计的目的。 任务：根据题目要求，完成算法设计与程序实现，并按规定写出课程设计报告。 二、课程设计的内容与基本要求 设计题目：用C语言实现成绩统计程序的设计 〔问题描述〕给出n个学生的m门课程的考试成绩信息，每条信息由姓名、课程代号与分数组成，要求设计算法： （1）输入每个人的各门课程的成绩，计算每人的平均成绩； （2）按平均成绩的高低次序，打印出个人的名次，平均成绩相同的为同一名次； （3）按名次列出每个学生的姓名和各科成绩； 〔基本要求〕学生的考试成绩必须通过键盘输入，且需对输出进行格式控制； 〔算法提示〕可以用选择排序、冒泡排序等多种排序算法求解； 具体要完成的任务是： A. 编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。 B. 写出规范的课程设计报告书； 三、课程设计步骤及时间进度和场地安排 时间：1周地点：现代教育中心 具体时间安排如下： 第一天：布置题目，确定任务、查找相关资料 第二天～第四天：功能分析，编写程序，调试程序、运行系统； 第五天上午：撰写设计报告； 第五天下午：程序验收、答辩。 四、课程设计考核及评分标准
一、实验目的 掌握图这种复杂的非线性结构的邻接矩阵和邻接表的存储表示，以及在此两种常用存储方式下深度优先遍历(DFS)和广度优先遍历(BFS)操作的实现。 二、实验内容与实验步骤 题目1：对以邻接矩阵为存储结构的图进行DFS 和BFS 遍历 问题描述：以邻接矩阵为图的存储结构，实现图的DFS 和BFS 遍历。 基本要求：建立一个图的邻接矩阵表示，输出顶点的一种DFS 和BFS 序列。 测试数据：如图所示 题目2：对以邻接表为存储结构的图进行DFS 和BFS 遍历 问题描述：以邻接表为图的存储结构，实现图的DFS 和BFS 遍历。 基本要求：建立一个图的邻接表存贮，输出顶点的一种DFS 和BFS 序列。 测试数据：如图所示 三、附录： 在此贴上调试好的程序。 #include
#define M 100 typedef struct node { char vex[M][2]; int edge[M ][ M ]; int n,e; }Graph; int visited[M]; Graph *Create_Graph() { Graph *GA; int i,j,k,w; GA=(Graph*)malloc(sizeof(Graph)); printf ("请输入矩阵的顶点数和边数(用逗号隔开)：\n"); scanf("%d,%d",&GA->n,&GA->e); printf ("请输入矩阵顶点信息：\n"); for(i = 0;i
数据结构课程设计报告 题目：5 班级:计算机1102 学号：4111110030 姓名：陈越 指导老师：王新胜
一：需求分析 1.运行环境 TC 2.程序所需实现的功能 几种排序算法的演示，要求给出从初始开始时的每一趟的变化情况，并对各种排序算法性能作分析和比较： （1）直接插入排序； （2）折半插入排序； （3）冒泡排序； （4）简单选择排序； （5）快速排序； （6）堆排序； （7）归并排序. 二：设计说明 1.算法设计的思想 1）、直接插入排序 排序过程：整个排序过程为n-1趟插入，即先将序列中第1个记录看成是一个有序子序列，然后从第2个记录开始，逐个进行插入，直至整个序列有序。 2)、折半插入排序 排序过程：用折半查找方法确定插入位置的排序叫折半插入排序。 3)、冒泡排序
排序过程：将第一个记录的关键字与第二个记录的关键字进行比较，若为逆序r[1].key>r[2].key，则交换；然后比较第二个记录与第三个记录；依次类推，直至第n-1个记录和第n个记录比较为止——第一趟冒泡排序，结果关键字最大的记录被安置在最后一个记录上。对前n-1个记录进行第二趟冒泡排序，结果使关键字次大的记录被安置在第n-1个记录位置。重复上述过程，直到“在一趟排序过程中没有进行过交换记录的操作”为止 4)、简单选择排序 排序过程：首先通过n-1次关键字比较，从n个记录中找出关键字最小的记录，将它与第一个记录交换。再通过n-2次比较，从剩余的n-1个记录中找出关键字次小的记录，将它与第二个记录交换。重复上述操作，共进行n-1趟排序后，排序结束。 5)、快速排序 基本思想：通过一趟排序，将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录进行排序，以达到整个序列有序。 排序过程：对r[s……t]中记录进行一趟快速排序，附设两个指针i和j，设枢轴记录rp=r[s]，x=rp.key。初始时令i=s,j=t。首先从j所指位置向前搜索第一个关键字小于x的记录，并和rp交换。再从i所指位置起向后搜索，找到第一个关键字大于x的记录，和rp交换。重复上述两步，直至i==j为止。再分别对两个子序列进行快速排序，直到每个子序列只含有一个记录为止。 6)、堆排序 排序过程：将无序序列建成一个堆，得到关键字最小（或最大）的记录；输