《数据结构》课程实验教学大纲Word文件下载.docx
《《数据结构》课程实验教学大纲Word文件下载.docx》由会员分享，可在线阅读，更多相关《《数据结构》课程实验教学大纲Word文件下载.docx（65页珍藏版）》请在冰豆网上搜索。
9
最小生成树的建立
10
排序和查找的算法
选作
三、对培养学生的能力要求
要求学生理解数据结构的基本算法，并能够用程序设计语言实现这些算法。
灵活运用数据结构的基本算法解决的实际问题，培养学生的数据抽象能力和复杂编程能力。
1.完成线性表的顺序存储结构和链式存储结构的基本操作的实现，并能设计实现线性的应用程序，提高编程能力。
2.完成栈和队列的顺序存储结构和链式存储结构的基本操作的实现。
3.完成二叉树和树的存储、遍历等基本操作的实现。
4.完成图的存储、遍历等基本操作的实现。
5.掌握各种查找和排序的算法，设计一个综合应用程序，为后续课程的应用打下基础。
四、本实验课程对学生的考核评分方法
本实验课程成绩应占整个课程成绩的10％；
考勤情况占整个实验成绩的的20％；
实验报告占整个实验成绩的70％；
五、说明
本实验教学大纲适用于计算机技术及应用专业、信息管理专业以及数统专业的本科生。
实验的学时总数为8学时。
可根据讲课进度安排上机时间，也可根据不同情况适当增加实验上机时数，以适应不同专业的需要。
《数据结构》课程
实验指导书
河北经贸大学信息技术学院
目录
实验1抽象数据类型6
实验2线性表的基本操作8
实验3栈和队列的基本操作16
实验4迷宫问题——递归21
实验5广义表的基本操作23
实验6二叉树的基本操作26
实验7哈夫曼树及哈夫曼编码31
实验8图的基本操作34
实验9最小生成树的建立43
实验10查找和排序46
实验1抽象数据类型
1实验目的
（1）熟悉抽象数据类型的表示与实现方法。
（2）复习高级编程语言C++的使用方法。
2实验内容
设计一个可进行复数运算的演示程序。
【基本要求】
实现下列六种基本运算：
（1）由输入的实部和虚部生成一个复数；
（2）两个复数求和；
（3）两个复数求差；
（4）两个复数求积；
（5）从已知复数中分离出实部；
（6）从已知复数中分离出虚部。
运算结果以相应的复数或实数的表示形式显示。
【测试数据】自定
参考程序如下：
//抽象数据类型复数的表示与实现
#include<
iostream.h>
typedefstructRECORD
{
doublereal;
doubleimage;
}cmptp;
intcreate（doublex,doubley,cmptp&
z）
{
z.real=x;
z.image=y;
return1;
}
intadd（cmptpz1,cmptpz2,cmptp&
sum）
{
sum.real=z1.real+z2.real;
sum.image=z1.image+z2.image;
intSUBSTRACT（cmptpz1,cmptpz2,cmptp&
difference）
difference.real=z1.real-z2.real;
difference.image=z1.image-z2.image;
intmultiply（cmptpz1,cmptpz2,cmptp&
product）
product.real=（z1.real*z2.real）-z1.image*z2.image;
product.image=z1.image*z2.real+z1.real*z2.image;
doublegetreal（cmptpz）
returnz.real;
doublegetimage（cmptpz）
returnz.image;
//上机调试验证
voidmain（）
cmptpz;
create（1,2,z）;
cout<
<
z.real<
z.image<
endl;
cmptpz1={3,4};
getreal（z1）<
cmptpz2={5,6};
cmptpsum;
add（z1,z2,sum）;
sum.real<
sum.image<
SUBSTRACT（z1,z2,sum）;
multiply（z1,z2,sum）;
3实验要求
按要求编写实验程序，将实验程序上机调试运行，并提交实验报告。
实验2线性表的基本操作
（1）熟练掌握线性表的逻辑特征。
（2）熟练掌握线性表的基本操作在两种存储结构上的实现。
2实验内容
（1）设计一个顺序表的基本操作的演示程序
（2）设计一个单链表的基本操作的演示程序
（3）设计一个双链表的基本操作的演示程序
实现下列4种基本运算：
（1）初始化线性表；
（2）在第I个元素前插入一个元素e；
（3）删除第I个元素；
（4）遍历线性表；
（5）将单链表逆置
//顺序表的基本操作
//顺序表的定义
#defineMAX15
typedefstruct{
intelem[MAX];
intlength;
}Sqlist;
voidInitlist_sq（Sqlist&
L）;
voidListInsert_sq（Sqlist&
L,inti,inte）;
voidListDel_sq（Sqlist&
L,inti,int&
e）;
voidprint_sq（SqlistL）;
//函数的定义
L）
L.length=0;
}
L,inti,inte）
int*p,*q;
if（i<
1||i>
L.length+1）return;
q=&
L.elem[i-1];
//插入位置
for（p=&
L.elem[L.length-1];
p>
=q;
--p）
*（p+1）=*p;
*q=e;
++L.length;
return;
e）
L.length）return;
e=L.elem[i-1];
for（intj=i;
j<
L.length;
j++）
L.elem[j-1]=L.elem[j];
--L.length;
voidprint_sq（SqlistL）
int*p,*q=L.elem+L.length-1;
for（p=L.elem;
p<
p++）
cout<
*p<
'
'
;
"
\n"
voidmain（）
inta[11]={10,20,30,40,50,60,70,80,90,100};
SqlistL;
//初始化顺序表
Initlist_sq（L）;
现在的表长：
"
L.length<
//插入10个数据元素
for（inti=1;
i<
=10;
++i）
ListInsert_sq（L,i,a[i-1]）;
插入10个元素后的线性表：
//遍历
print_sq（L）;
//删除第5个元素
intx;
ListDel_sq（L,5,x）;
删除的元素值是：
x<
删除第5个元素后的表：
//单链表的操作
structNODE
intdata;
NODE*next;
};
voidprint（NODE*&
head）;
intdata[6]={25,41,17,98,5,6};
voidSetup_L（NODE*&
head,intn）;
//生成单链表
voidInsert_L（NODE*&
head,intI,inte）;
//插入
voidDelete_L（NODE*&
head,intI,int&
//删除
voidConvert_L（NODE*&
head）；
//逆序
NODE*L;
Setup_L（L,6）;
print（L）;
//Insert_L（L,7,50）;
Delete_L（L,0,x）;
X="
Convert_L（L）;
head）
NODE*p;
p=head->
next;
while（p）
p->
data<
"
;
//输出元素值
p=p->
next;
//后移指针
voidSetup_L（NODE*&
head,intn）
NODE*q,*p;
head=（NODE*）newNODE;
head->
next=NULL;
//先建立一个带头结点的单链表
q=head;
for（inti=0;
n;
i++）{
p=（NODE*）newNODE;
//生成新结点
p->
data=data[i];
q->
next=p;
q=p;
//插入到表头
next=NULL;
NODE*p=L,*q;
intj=0;
while（p&
&
i-1）
{p=p->
j++;
if（!
p||j>
{cout<
插入值超出范围！
q=（NODE*）newNODE;
data=e;
next=p->
next=q;
voidDelete_L（NODE*&
L,inti,int&
删除值超出范围！
q=p->
e=q->
data;
next=q->
deleteq;
NODE*p,*q,*r;
p=L->
while（q）
r=q->
q->
next=p;
L->
next=q;
p=q;
q=r;
//双链表的基本操作
NODE*prior;
};
intdata[6]={3,5,7,19,20,21};
//测试用数据
//函数声明
voidSetup_L（NODE*&
L,inti,inte）;
voidConvert_L（NODE*&
//主函数和各函数的定义
Insert_L（L,7,50）;
print（L）;
Delete_L（L,1,x）;
{//从头开始顺序输出双连表中的数据
{cout<
"
p=p->
}
{//创建一个带头结点的双连表
p=（NODE*）newNODE;
p->
//cin>
>
data;
prior=q;
q->
q=p;
//return（head）;
L,inti,inte）
{//在带头结点的双链表中第i个位置插入元素e
NODE*p=L,*q;
//j为计数器
i-1）
{p=p->
}//寻找第i-1个结点
i-1）//i小于1或大于表长
插入值超出范围!
if（p->
next==NULL）
{q->
next=p->
else
next->
prior=p;
}//插入L中
voidDelete_L（NODE*&
{//在带头结点的双链表L中，删除第i个元素，并由e返回其值
i-1）//寻找第i-1个结点
删除值超出范围!
//删除位置不合理
next=q->
}//删除并释放结点
实验3栈和队列的基本操作
（1）深入了解栈和队列的基本特性
（2）熟练掌握栈的基本操作在两种存储结构上的实现。
（3）熟练掌握循环队列的基本操作
（4）熟练掌握链队列的基本操作
（1）设计一个顺序栈的基本操作的演示程序
（2）设计一个链栈的基本操作的演示程序
（3）设计一个循环队列的基本操作的演示程序
（4）设计一个链队列的基本操作的演示程序
实现下列6种基本运算：
（1）初始化；
（2）入栈（队列）；
（3）出栈（队列）；
（4）遍历；
（5）求栈（队列）的长度
//顺序栈的基本操作
#defineMAX10
intbase;
inttop;
intst[MAX];
}SqStack;
//基本操作说明
voidInitStack（SqStack&
S）;
voidpush（SqStack&
S,inte）;
voidpop（SqStack&
S,int&
//基操作的算法描述
voidInitStack（SqStack&
S）
S.base=S.top=0;
voidpush（SqStack&
S,inte）
if（S.top==MAX）
”栈满\n”;
S.st[S.top]=e;
S.top+=1;
if（S.top==0）
”栈空\n”;
S.top-=1;
e=S.st[S.top];
voidprint（SqStackS）
”栈的各个元素如下：
\n”;
for（intI=0;
I<
S.top;
I++）
S.st[I]<
”“;
SqStackS;
//初始化
”初始化栈\n”;
InitStack（S）;
”栈底和栈顶：
”<
S.base<
”,”<
S.top<
//入栈
”5个元素入栈\n”;
5;
push（S,2*I+1）;
”栈顶为：
S.top<
print（S）;
//出栈
pop（S,x）;
”出栈元素为：
”栈顶”<
//循环队列的基本操作
#defineMAX8
typedefstruct
intbase[MAX];
intfront;
intrear;
}SqQueue;
/***********初始化**************/
voidInitQueue（SqQueue&
Q）
Q.front=Q.rear=0;
//******求队列长度******//
intQueueLength（SqQueueQ）
return（Q.rear-Q.front+MAX）%MAX;
//*****入队列****************//
voidEnQueue（SqQueue&
Q,inte）
if（（Q.rear+1）%MAX==Q.front）
”队列满！
else
{Q.base[Q.rear]=e;
Q.rear=（Q.rear+1）%MAX;
//*******遍历队列******//
voidtraverse（SqQueue&
Q）
intI,k;
if（Q.front<
=Q.rear）
k=0;
k=1;
switch（k）
case0:
for（I=Q.front;
Q.rear;
Q.base[I]<
break;
case1:
for（I=Q.front;
MAX;
for（I=0;
Q.rear;
break;
/**************出队************/
intDeQueue（SqQueue&
Q,int&
if（Q.rear==Q.front）return–1;
e=Q.base[Q.front];
Q.front=（Q.front+1）%MAX;
SqQueueQ;
InitQueue（Q）;
intj,m,x;
for（j=0;
7;
EnQueue（Q,2*j）;
traverse（Q）;
m=QueueLength（Q）;
cout<
”\n长度”<
m<
EnQueue（Q,500）;
DeQueue（Q,x）;
升级会员 