数据结构课程设计指导书.docx
《数据结构课程设计指导书.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计指导书.docx（38页珍藏版）》请在冰豆网上搜索。
数据结构课程设计指导书
2008年数据结构课程设计指导书
一、课程设计的基本要求和方法
1.课程设计题目要求从程序调试类题目和程序编写类题目中各选其一，多选不限。
2.课程设计资料应装入学校统一的课程设计专用资料袋中，资料袋封面应填写完整，课程设计的全部纸质文档资料应装入课程设计资料袋中。
3.应提交的资料包括：
（1）纸质的课程设计报告1份纸质文档（报告封面见附件1，内容见附件2）；
（2）将源程序、课程设计报告、课程设计心得的电子文档按规定的文件名称和格式放在自己学号所建的文件夹下，并拷贝到指导教师指定的文件夹中。
文件夹和文件的命名规范为：
班级+姓名+学号，例如071张三20071002001。
4.课程设计说明书应包括封面、目录、正文和参考文献等部分，一律用A4纸张打印，侧面装订，正文用5号宋体。
5.学生课程设计资料的质量由学生保证，由指导教师验收。
6.发现课程设计报告基本雷同情况，一律不及格。
二、课程设计说明书撰写应包括的内容
1、对自己此次课程设计进行概述（包括该次课程设计自己所做的题目，所用的编程工具等）
2、课程设计题目一（包括问题描述；需求分析（基本要求）、设计（概要设计（所用函数及说明）、所用数据结构及存储结构、算法思想、关键函数的流程图）、实现（源程序清单及注释））；调试分析；运行结果分析）
3、课程设计题目二（包括问题描述；需求分析（基本要求）、设计（概要设计（所用函数及说明）、所用数据结构及存储结构、算法思想、关键函数的流程图）、实现（源程序清单及注释））；运行结果分析）
4、参考文献（至少三项，格式按照科技论文的参考文献格式）
三、数据结构课程设计题目
（—）程序调试类题目
1、单链表的基本操作
程序清单：
#include"stdio.h"
#include"alloc.h"
typedefstructlnode
{
charvalue;
structlnode*link;
}llistnode;
llistnode*creat（）
{
llistnode*head,*p;
charch;
head=malloc（sizeof（llistnode））;
head->link=NULL;
printf（"input:
"）;
while（（ch=getchar（））!
='\n'）
{p=malloc（sizeof（llistnode））;
p->value=ch;
p->link=head->link;
head->link=p;
printf（"input:
"）;
}
returnhead;
}
voidprint（llistnode*head）
{llistnode*p;
printf（"\n"）;
p=head->link;
while（p）
{printf（"%c",p->value）;
p=p->link;
}
}
llistnode*visitll（llistnode*h,charx）
{
llistnode*p;
p=h;
while（（p->value!
=x）&&（p!
=NULL））
p=p->link;
return（p）;
}
llistnode*predall（llistnode*h,llistnode*q）
{
llistnode*p;
if（q==h）
p=NULL;
else
{p=h;
while（（p->link!
=q）&&（p!
=NULL））
p=p->link;
}
return（p）;
}
voidinsertll（llistnode*h,llistnode*q,charx）
{
llistnode*p,*r;
r=（llistnode*）malloc（sizeof（llistnode））;
r->value=x;
if（h==q）
h=r;
else
{p=predall（h,q）;
p->link=r;
}
r->link=q;
}
voiddeletell（llistnode*h,llistnode*q）
{
llistnode*p;
if（h==q）
h=q->link;
else
{
p=predall（h,q）;
p->link=q->link;
}
free（q）;
}
main（）
{llistnode*a;
llistnode*result=NULL;
intchoice;
chardata,data_cz;
a=creat（）;
while
（1）
{
printf（"\n以下是单链表的应用,请选择:
"）;
printf（"\n1、遍历链表并依次输出其的结点值"）;
printf（"\n2、在链表中查找是否存在某结点"）;
printf（"\n3、在链表中查找某结点的前驱"）;
printf（"\n4、在链表中查找某结点的后继"）;
printf（"\n5、在链表中插入结点"）;
printf（"\n6、在链表中删除结点"）;
printf（"\n7、退出"）;
scanf（"%d",&choice）;
switch（choice）
{
case1:
print（a）;
break;
case2:
getchar（）;
printf（"请输入待查结点的值:
"）;
data=getchar（）;
result=visitll（a,data）;
if（result!
=NULL）
printf（"%c在链表中",data）;
else
printf（"%c不在链表中",data）;
result=NULL;
break;
case3:
getchar（）;
printf（"请输入待查结点的值:
"）;
data=getchar（）;
result=visitll（a,data）;
if（result==NULL）
{
printf（"%c不在链表中",data）;
break;
}
result=predall（a,result）;
if（result!
=NULL）
printf（"%c的前驱是%c",data,result->value）;
else
printf（"%c没有前驱",data）;
result=NULL;
break;
case4:
getchar（）;
printf（"请输入待查结点的值:
"）;
data=getchar（）;
result=visitll（a,data）;
if（result==NULL）
{
printf（"%c不在链表中",data）;
break;
}
if（result->link!
=NULL）
printf（"%c的后继是%c",data,result->link->value）;
else
printf（"%c没有后继",data）;
result=NULL;
break;
case5:
getchar（）;
printf（"请输入待插结点的值:
"）;
data=getchar（）;
getchar（）;
printf（"请输入插入在哪个结点前面:
"）;
data_cz=getchar（）;
result=visitll（a,data_cz）;
if（result==NULL）
{
printf（"%c不在链表中",data）;
break;
}
insertll（a,result,data）;
break;
case6:
getchar（）;
printf（"请输入待删除结点的值:
"）;
data=getchar（）;
result=visitll（a,data）;
if（result==NULL）
{
printf（"%c不在链表中",data）;
break;
}
deletell（a,result）;
break;
case7:
break;
defalut:
break;
}
if（choice==7）
break;
}
}
要求及提示：
1、要求写出每一个函数的功能。
2、（选作）若现在要建立的链表为双向链表，则程序应如何修改，试实现之。
2.用数组实现两个矩阵的相乘运算
程序结构：
#include“stdio.h”
intr[6][6];
voidmult（inta[6][6],intb[6][6]）
{}
main（）
{
inti,j;
intnum1[6][6],num2[6][6];
printf（“请输入第一个矩阵的值:
”,）;
for（i=1;i<=6;i++）
for（j=1;j<=6;j++）
scanf（“%d”,&num1[i][j]）;
printf（“请输入第二个矩阵的值:
”,）;
for（i=1;i<=6;i++）
for（j=1;j<=6;j++）
scanf（“%d”,&num2[i][j]）;
mult（num1,num2）;
printf（“\n两个矩阵相乘后的结果为：
”）;
for（i=1;i<=6;i++）
{for（j=1;j<=6;j++）
printf（“%4d”,r[i][j]）;
printf（“\n”）;
}
}
要求及提示：
1、要求完善函数mult（）,
2、现有A,B两个矩阵，要求用上述程序求出A与B相乘后的运行结果,
413690310124
731421131052
010291192130
A=410260B=912400
121015300101
300512210689
3、按层次遍历二叉树
程序清单：
#include“stdio.h”
#include“stdio.h”
#defineqsize10
structnode
{chardata;
structnode*lchild;
structnode*rchild;
}bnode;
typedefstructnode*blink;
typedefstruct
{intfront,rear,count;
blinkdata[qsize];
}cirq;
cirq*q;
voidinitq（cirq*q）
{q->front=q->rear=0;
q->count=0;}
intqempty（cirq*q）
{returnq->count==0;}
voidenq（cirq*q,blinkx）
{q->count++;
q->data[q->rear]=x;
q->rear=（q->rear+1）%qsize;}
blinkdeq（cirq*q）
{blinktemp;
temp=q->data[q->front];
q->count--;
q->front=（q->front+1）%qsize;
returntrmp;}
blinkcreat（）
{blinkbt;
charch;
ch=getchar（）;
if（ch!
=’#’）
{bt=malloc（sizeof（bnode））;
bt->data=ch;
bt->lchild=creat（）;
bt->rchild=create（）;
}
else
bt=NULL;
returnbt;}
voidlevel（blinkbt）
{blinkp;
p=bt;
init（q）;
if（p）
{printf（“%c”,p->data）;
enq（q,p）;}
while（!
qempty（q））
{p=deq（q）;
if（q->lchild）
{printf（“%c”,p->lchild->data）;
emq（q,p->lchild）;}
if（q->rchild）
{printf（“%c”,p->rchild->data）;
emq（q,p->rchild）;}
}
}
main（）
{blinkroot;
root=creat（）;
printf（“\n”）;
level（root）;
printf（“\n”）;
}
4、快速排序
程序清单：
#include“stdio.h”
#definemax100
intr[max];
voidquicksortL（intr[],ints,intt）
{
inti,j;
i=s;
j=t;
r[0]=r[s];
while（i{while（（r[0]<=r[j]）&&（ij--;
if（i{r[i]=r[j];
i++;
}
while（（r[0]>=r[i]）&&（ii++;
if（i{r[j]=r[i];
j--;
}
}
r[i]=r[0];
if（squicksortL（r,s,i-1）;
if（t>i+1）
quicksortL（r,i+1,t）;
}
main（）
{
inti,n;
printf（“请输入待排序元素的个数（少于100个）：
）;
scanf（“%d”,&n）;
for（i=1;i<=n;i++）
{printf（“请输入第%d个元素”,i）;
scanf（“%d”,&r[i]）;
}
quicksortL（r,1,n）;
printf（“排序结束后为：
\n”）;
for（i=1;i<=n;i++）
printf（“%4d”,r[i]）;
}
要求及提示：
1、对12、34、13、6、79、10、56用上述算法进行快速排序，写出运行结果。
2、写出12、34、13、6、79、10、56用上述算法进行的第一趟快速排序后的结果。
5.堆排序
程序结构：
#include“stdio.h”
#definemax100
intr[max];
voidsift（intr[],inti,inth）
{
intj;
r[0]=r[i];
j=2*i;
while（j<=h）
{if（（jr[j+1]）}
j++;
if（r[0]>r[j]）
{r[i]=r[j];
i=j;
j=2*i;
}
else
break;
}
r[i]=r[0];
}
voidheapsortL（intr[],intn）
{intm,i;
m=n/2;
for（i=m;i>=1;i--）
sift（r,i,n）;
for（I=n;i>=1;i--）
{r[0]=r[1];r[1]=r[i];r[i]=r[0];
sift（r,1,i-1）;
}
}
main（）
{
inti,n;
printf（“请输入排序元素的个数（少于100个）：
”）;
scanf（“%d”,&n）;
for（i=1;i<=n;i++）
{printf（“请输入第%d个元素”,i）;
scanf（“%d”,&r[i]）;
}
heapsortL（r,n）;
printf（“排序结束后为：
\n”）;
for（i=1;i<=n;i++）
printf（“%4d”,r[i]）;
}
要求及提示：
3、对12、34、13、6、79、10、56用上述算法进行堆排序，写出运行结果。
4、画出12、34、13、6、79、10、56用上述算法建立的初始堆。
6、二叉树的建立及操作
程序清单：
#include“stdio.h”
#include“alloc.h”
structnode
{chardata;
structnode*lchild,*rchild;
}bnode;
typedefstructnode*blink;
blinkcreat（）
{blinkbt;
charch;
ch=getchar（）;
if（ch!
=’#’）
{
bt=malloc（sieof（bnode））;
bt->data=ch;bt->lchild=creat（）;
bt->rchile=creat（）;
}
else
bt=NULL;
returnbt;
}
voidpreorder（blinkbt）
{
if（bt）
{printf（“%c”,bt->data）;
preorder（bt->lchild）;
preorder（bt->rchild）;
}
}
voidinorder（blinkbt）
{
if（bt）
{
inorder（bt->lchild）;
prnitf（“%c”,bt->data）;
inorder（bt->rchild）;
}
}
voidpostorder（blinkbt）
{
if（bt）
{
postorder（bt->lchild）;
postorder（bt->rchild）;
printf（“%c”,bt->data）;
}
}
intmax（intx,inty）
{
if（x>y）
returnx;
else
returny;
}
intdepth（blinkbt）
{
if（bt）
retur1+max（depth（bt->lchild）,depth（bt->rchild））;
else
return0;
}
main（）
{
blinkroot;
root=creat（）;
printf（“\n”）;
printf（“先序遍历结果:
”）;
preorder（root）;
printf（“\n”）;
printf（”中序遍历结果:
”）;
inorder（root）;
printf（“\n”）;
printf（“后序遍历结果:
”）;
postorder（root）;
printf（“\n”）;
printf（“depth=%d\n”,depth（root））;
}
7、无向图的建立及遍历操作
程序清单：
#include“stdio.h”
#include“alloc.h”
typedefstructnode
{
intadjvex;
structnode*next;
}edgenode;
tyedefstructvnode
{intvertex;
edgenode*firstedge;
}vertexnode;
typedefvertexnodeadjlist[10];
typedefstruct
{
adjlistal;
intn,e;
}graph;
graph*g;
intvisited[10];
graph*creat（）
{inti,j,k;
edgenode*s;
scanf（“%d%d”,&g->n,&g->e）;
for（i=1;i<=g->n;i++）
g->al[i].firstedge=NULL;
for（i=1;k<=g->e;k++）
{
scanf（“%d%d”,&i,&j）;
s=malloc（sizeof（edgenode））;
s->adjvex=j;
s->next=g->al[i].firstedge;
g->al[i].firstedge=s;
s=malloc（sizeof（edgenode））;
s->adjvex=i;
s->next=g->al[j].firstedge;
g->al[j].firstedge=s;
}
returng;
}
voiddfs（graph*g,inti）
{
edgenode*p;
printf（“visitvertext:
%d\n”,i）;
visited[i]=1;
p=g->al[i].firstedge;
while（p）
{
if（!
visited[p->adjvex];
dfs（g,p->adjvex）;
p=p->next;
}
}
main（）
{
inti;
graph*g;
g=creat（）;
for（i=1;i<=g->n;i++）
visited[i]=0;
for（i=1;i<=g->n;i++）
if（!
visited[i]）
dfs（g,i）;
}
要求及提示：
1、对于上图无向图的建立,应输入:
44
12
13
23
24
2、上图建立的邻接表为
1
（二）程序编写类题目
1.迷宫问题
[问题描述]
以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。
设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。
[基本要求]
（1）实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。
求得的通路以三元组（i,j,d）的形式输出，其中：
（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。
（2）编写递归形式的算法，求得迷宫中所有可能的通路；
（3）
升级会员 