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