数据结构课程设计.docx
《数据结构课程设计.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计.docx（35页珍藏版）》请在冰豆网上搜索。
数据结构课程设计
大学
数据结构——课程设计报告说明书
題目：
教学学习系统
学院：
计算机科学学院
班级：
组长：
组员：
完成日期：
2010.12.23
指导老师：
第一章：
需求分析……………………………….…………….....1
第二章：
概要设计…………………………………………..……1
第三章：
详细设计………………………………………………..5
3.1约瑟夫环…………………....……………………………….5
3.2二叉树遍历……………………….....……………………….5
3.3哈希表........………………………………………………….5
3.4图的遍历.…………...……………………………………….6
3.5回文判断…………………………………………………….6
3.6成绩统计…........…………………………………………….6
第四章：
调试分析………………………………………………..7
第五章：
用户使用说明…………………………………………..7
第六章：
心得体会………………………………………………..7
第七章：
测试结果..........................................................................8
第八章：
程序清单..........................................................................9
1.需求分析：
本课程设计的任务是根据对回文判断，约瑟夫环，链表，二叉树的遍历，图的优先广度搜索，学生成绩统计的调用。
实现对不同算法的学习。
（1）输入形式：
字母和数字
在主界面输入1-6进入6个不同模块。
进入子模块后，按照相应的提示输入正确的实例变量。
（2）输出：
字符
（3）程序的功能：
（4）模块1：
按照约瑟夫问题，打印各人的编号。
模块2：
对二叉树进行遍历。
模快3：
利用除留余数法，构造哈希函数，解决链表冲突。
模块4：
对图进行深度优先遍历。
模块5：
对数字进行回文判断。
模块6：
统计学生成绩。
运行操作环境：
WindowsXP;
MicrosoftVisualC++6.0;
程序语言：
C语言
2.概要设计
（1）约瑟夫环
为了实现上述程序功能，需要定义单链表的抽象数据类型：
Node
数据对象：
intnumberOfThis;intcodeOfThis;
数据关系：
count!
=numberOfJosephus
基本操作：
链表的创建,s=（Node*）malloc（sizeof（Node））;将链表变成循环链表：
RH=temp;RH->next=H;temp=H;进行比较踢人;while（count!
=numberOfJosephus）
（2）二叉树遍历：
为了实现上述程序功能，需要定义树的结构体数据类型：
BiTNode,*BiTree
数据对象：
chardata;structBiTNode*lchild,*rchild;
数据关系：
CreatBiTree（&（（*T）->lchild））;
CreatBiTree（&（（*T）->rchild））;
主要操作：
树的创建:
CreatBiTree（&T）;
操作结果：
构造一个二叉树T.
先序遍历二叉树:
voidPreTravel（BiTreeT）;
初始条件：
树T存在
操作结果：
先序输出二叉树
中序遍历二叉树：
voidInOrderTravel（BiTreeT）;
初始条件：
树T存在
操作结果：
中序输出二叉树
（3）哈希表
为了实现上述程序功能，需要定义树的结构体数据类型：
sname
数据对象：
charname[15];intflag;typedefsnamehtable;
数据关系：
hashsearch（htableht[],charname[]）
主要操作：
创建链表:
voidcreate（htableht[],intst_num）
操作结果：
构造一个链表
查找哈希表:
inthashsearch（htableht[],charname[]）
初始条件：
链表存在
操作结果：
显示经过处理之后的链地址
（4）图的遍历：
为了实现上述程序功能，需要定义树的结构体数据类型：
数据对象：
intvexs[MAX_VERTEX_NUM];
intarcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
intvexnum,arcnum;
数据关系：
DfsTraverse（G）;BfsTraverse（G）;
主要操作：
图的创建:
CreateGraph（&G）
操作结果：
构造一个图.
深度优先搜索:
DfsTraverse（G）;
初始条件：
图g存在
操作结果：
广度优先搜索：
BfsTraverse（G）;
初始条件：
图graph存在
操作结果：
（5）回文判断
为了实现上述程序功能，需要定义树的结构体数据类型：
Stack
数据对象：
char*Base;char*Top;
数据关系：
S->Base=（char*）malloc（size）;
S->Top=S->Base;
主要操作：
栈的创建:
voidCreateStack（Stack*S,intsize）
操作结果：
构造一个盏S
入栈:
voidPush（Stack*S,charc）
初始条件：
栈存在
操作结果：
元素存入栈中
出栈：
voidPop（Stack*S）
初始条件：
栈存在
操作结果：
栈中元素输出
（6）成绩统计：
为了实现上述程序功能，需要定义树的结构体数据类型：
sqlist
数据对象：
intkey;charname[20];
数据关系：
l.r[j+1]=l.r[j];l.r[j+1]=l.r[0];
主要操作：
成绩统计:
intchengJiTongJi（）
操作结果：
得到存数据的链表
成绩输出:
voidshuChu（sqlistl）
初始条件：
存在存成绩的链表
操作结果：
输出成绩
成绩排序：
voidinsersort（sqlistl）
初始条件：
存在存成绩的链表
操作结果：
成绩从大到小排序
3．详细设计
实现概要设计中定义的所有的数据类型，对每个操作给出伪码算法。
对主程序和其他模块也都需要写出伪码算法。
（1）约瑟夫环：
结点类型和结构体指针类型：
typedefstructNode
{
intnumberOfThis;
intcodeOfThis;
structNode*next;
}Node;
基本操作：
链表的创建,s=（Node*）malloc（sizeof（Node））;将链表变成循环链表：
RH=temp;RH->next=H;temp=H;进行比较踢人;while（count!
=numberOfJosephus）
（2）二叉树遍历：
结点类型和结构体指针类型：
typedefstructBiTNode
{
chardata;
structBiTNode*lchild,*rchild;
}BiTNode,*BiTree;
主要模块：
树的创建:
CreatBiTree（&T）;
先序遍历二叉树:
voidPreTravel（BiTreeT）;
中序遍历二叉树：
voidInOrderTravel（BiTreeT）;
操作调用函数：
（3）哈希表：
结点类型和结构体指针类型：
typedefstruct
{
charname[15];
intflag;
}sname;
typedefsnamehtable;
主要模块：
创建链表:
voidcreate（htableht[],intst_num）
查找哈希表:
inthashsearch（htableht[],charname[]）
操作调用函数：
（4）图的遍历：
结点类型和结构体指针类型：
typedefstruct
{
intvexs[MAX_VERTEX_NUM];
intarcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
intvexnum,arcnum;
}AdjMatrix;
主要模块：
图的创建:
CreateGraph（&G）深度优先搜索:
DfsTraverse（G）;
广大优先搜索：
BfsTraverse（G）;
操作调用函数：
（5）回文判断
结点类型和结构体指针类型：
typedefstructStack
{
intsize;
char*Base;
char*Top;
}Stack;
主要模块：
栈的创建:
voidCreateStack（Stack*S,intsize）
入栈：
voidPush（Stack*S,charc）
出栈：
voidPop（Stack*S）
操作调用函数：
（6）成绩统计
结点类型和结构体指针类型：
typedefstruct{
intkey;
charname[20];
}redtype;
typedefstruct{
redtyper[MAXSIZE+1];
intlength;
}sqlist;
主要模块：
成绩统计:
intchengJiTongJi（）
成绩输出:
voidshuChu（sqlistl）
成绩排序：
voidinsersort（sqlistl）
操作调用函数：
4调试分析
（1）在编写程序时，熟练利用指针进行传递，提高效率。
（2）在哈希表调试过程中，对创建链表长度难以控制，导致平均长度偏大。
通过对数据的认真分析加之多次修改达到目的。
（3）在二叉树的创建中，要注意正确创建二叉树利用递归实现对二叉树的遍历。
5用户使用说明
进入主界面，用户可选择自己所需功能进行选择，输入1-6代码，进入所选模块，进行运行。
6实验心得体会
这次课程设计，大家都积动手，积极思考，努力发现问题，解决问题。
通过这次课程设计，使大家一改过去“程序太长，肯定写不出来的观点”，编程的能力都有很大的提高。
7测试结果
1．哈希表2学生成绩统计
（1）
学生成绩统计
（2）3.二叉树
4．回文判断5.约瑟夫环
6.图的遍历
8程序清单
#include
#include
//****************************
（一）哈希表*******************************
#include"stdio.h"
#include
#defineM13
#defineN12
structhterm
{charname[15];
intkey;//关键字值
intsi;//散列次数
};
structhtermhashlist[M+1];
inti,address,sum,d,name[N+1];
floataverage;
haXiBiao（）
{{
for（i=0;i<=M;i++）//置初值
{hashlist[i].key=0;
hashlist[i].si=0;
}
for（i=0;i{
printf（"请输入第%d学生姓名:
（请输入学生姓氏的首字母）\n",i+1）;
scanf（"%s",name）;
sum=0;
address=name[0]%M;
d=address;
if（hashlist[address].key==0）
{
hashlist[address].key=name[0];
hashlist[address].si=1;
}
else
{
do//处理冲突
{d=（d+5）%M;
sum=sum+1;
}while（hashlist[d].key!
=0）;
hashlist[d].key=name[0];
hashlist[d].si=sum+1;
}
}
printf（"散列表地址:
\n"）;
for（i=0;iprintf（"\n"）;
printf（"散列表关键字:
\n"）;
for（i=0;iprintf（"\n"）;
printf（"查找长度:
\n"）;
for（i=0;iprintf（"\n"）;
average=0;
for（i=0;iaverage=average/N;
printf（"平均查找长度：
ASL（%d）=%g",N,average）;
}
printf（"\n\n请选择\n输入1返回主界面\n否则运行结束\n"）;
scanf（"%d",&i）;
if（i==1）
return
（1）;
else
return（0）;
}
//********************************
（二）二叉树程序**********************
//节点结构体
typedefstructBiTNode
{
chardata;
structBiTNode*lchild,*rchild;
}BiTNode,*BiTree;
//***********先序建立二叉树中的节点**
voidCreatBiTree（BiTree*T）
{
charch;
fflush（stdin）;
if（（ch=getchar（））=='\n'）
*T=NULL;
else
{
（*T）=（BiTNode*）malloc（sizeof（BiTNode））;
if（!
（*T））
exit
（1）;
（*T）->data=ch;
CreatBiTree（&（（*T）->lchild））;
CreatBiTree（&（（*T）->rchild））;
}
}
//***************先序遍历二叉树**********************
voidPreTravel（BiTreeT）
{
if（T）
{
printf（"%c",T->data）;
PreTravel（T->lchild）;
PreTravel（T->rchild）;
}
}
//*************中序遍历******************
voidInOrderTravel（BiTreeT）
{
if（T）
{
InOrderTravel（T->lchild）;
printf（"%c",T->data）;
InOrderTravel（T->rchild）;
}
}
interChaShu（）
{inti;
BiTreeT;
printf（"pleaseinputBiTree:
\n"）;
printf（"按列输入，一次输入一个字符:
\n"）;
printf（"若输入n个数，回车n+2次:
\n"）;
CreatBiTree（&T）;
printf（"ThePerTravelis\n"）;
PreTravel（T）;
printf（"\nTheInOrderTravelis\n"）;
InOrderTravel（T）;
printf（"请选择\n输入1返回主界面\n否则运行结束\n"）;
scanf（"%d",&i）;
if（i==1）
return
（1）;
else
return（0）;
}
//**************************（三）图的遍历********************************
/*图的类型定义*/
typedefstructArcCell
{VRTypeadj;/*图中有1/0表示是否有边，网中表示边上的权值*/
/*InfoType*info;与边相关的信息*/
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedefstruct
{VertexTypevexs[MAX_VERTEX_NUM];/*顶点向量*/
AdjMatrixarcs;/*邻接矩阵*/
intvexnum,arcnum;/*图中当前顶点数和边数*/
}MGraph;
/*建立无向图的邻接矩阵*/
voidCreateGraph（MGraph*G）
{inti,j,k;VertexTypev1,v2;
printf（"\n输入图的顶点和边数:
"）;
scanf（"%d,%d",&（*G）.vexnum,&（*G）.arcnum）;
printf（"输入%d顶点:
",（*G）.vexnum）;
for（i=0;i<（*G）.vexnum;i++）/*输入顶点向量*/
{scanf（"%s",（*G）.vexs[i]）;}
printf（"顶点列表\n"）;
for（i=0;ivexnum;i++）/*输出顶点向量*/
puts（G->vexs[i]）;
for（i=0;i<（*G）.vexnum;i++）/*邻接矩阵初始化*/
for（j=0;j<（*G）.vexnum;j++）
（*G）.arcs[i][j].adj=0;
printf（"\n输入%d边（vivj）:
\n",（*G）.arcnum）;
for（k=0;k<（*G）.arcnum;k++）/*输入无权图的边*/
{scanf（"%s%s",v1,v2）;
i=LocateVex（*G,v1）;j=LocateVex（*G,v2）;
（*G）.arcs[i][j].adj=1;
（*G）.arcs[j][i]=（*G）.arcs[i][j];
}
}
/*顶点在顶点向量中的定位*/
intLocateVex（MGraphG,VertexTypev）
{inti;
for（i=0;iif（strcmp（v,G.vexs[i]）==0）break;
returni;
}
/*查找第1个邻接点*/
intFirstAdjVex（MGraphG,intv）
{intj,p=-1;
for（j=0;jif（G.arcs[v][j].adj==1）{p=j;break;}
returnp;
}
/*查找下一个邻接点*/
intNextAdjVex（MGraphG,intv,intw）
{intj,p=-1;
for（j=w+1;jif（G.arcs[v][j].adj==1）{p=j;break;}
returnp;
}
/*按邻接矩阵方式输出无向图*/
voidPrintGraph（MGraphG）
{inti,j;
printf（"\n无向图:
"）;
for（i=0;i{
printf（"%4s",G.vexs[i]）;
}
printf（"\n"）;
for（i=0;i{printf（"%10s",G.vexs[i]）;
for（j=0;jprintf（"%4d",G.arcs[i][j].adj）;
printf（"\n"）;
}
}
/*图的深度优先遍历*/
intvisited[MAX_VERTEX_NUM];/*设置全局的访问标志数组*/
voidDfs（MGraphG,intv）
{intw;
visited[v]=1;
printf（"%s",G.vexs[v]）;
for（w=FirstAdjVex（G,v）;w>=0;w=NextAdjVex（G,v,w））
if（!
visited[w]）Dfs（G,w）;
}
voidDfsTraverse（MGraphG）
{intv;
for（v=0;vvisited[v]=0;
for（v=0;vif（!
visited[v]）Dfs（G,v）;
}
/*图的广度优先遍历算法*/
voidBfsTraverse（MGraphG）
{intv,u,w;LinkQueueQ;
for（v=0;vInitQueue（&Q）;
for（v=0;vif（!
visited[v]）
{visited[v]=1;
printf（"%s",G.vexs[v]）;
EnQueue（&Q,v）;
while（!
QueueEmpty（Q））
{DeQueue（&Q,&u）;
for（w=FirstAdjVex（G,u）;w>=0;w=NextAdjVex（G,u,w））
if（!
visited[w]）
{visited[w]=1;
printf（"%s",G.vexs[w]）;
EnQueue（&Q,w）;
}
}
}
}
/*主函数*/
tuDeBianLi（）
{intw,i;
MGraphG;
printf（"图的遍历算法"）;
CreateGraph（&G）;
PrintGraph（G）;
printf（"\n深度优先遍历:
"）;
DfsTraverse（G）;/*深度遍历*/
printf（"\n广度优先遍历:
"）;
BfsTraverse（G）;/*广度遍历*/
system（"pause"）;
printf（"\n\n请选择\n输入1返回主界面\n否则运行结束\n"）;
scanf（"%d",&i）;
if（i==1）
return
（1）;
else
return（0）;
}//******************
升级会员 