数据结构实验指导书.docx
《数据结构实验指导书.docx》由会员分享，可在线阅读，更多相关《数据结构实验指导书.docx（35页珍藏版）》请在冰豆网上搜索。
数据结构实验指导书
数据结构实验指导书
实验一、线性表（2学时）
1.设计实验
设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求：
（1）从键盘输入10个整数，产生顺序表，并输入结点值。
（2）从键盘输入1个整数，在顺序表中查找该结点的位置11。
若找到，输出结点的位置；若找不到，则显示“找不到”。
（3）从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。
（4）从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。
2.实验报告
完成实验一实验报告。
格式统一按“实验报告格式”，注意内容部分有页眉页脚。
报告中实验原理部分需包括程序设计的基本思想，原理；
实验过程部分需包括源程序及注释和调试、运行程序过程中产生的问题及采取的措施；
实验结果部分需包括运行输出结果及对算法的程序的讨论、分析，改进设想，其它经验教训。
另还可就实验方式、组织、设备、题目提出意见和建议。
提示：
可参考以下思路进行设计：
#include
#include
//顺序表的定义：
#defineListSize100//表空间大小可根据实际需要而定，这里假设为100
typedefintDataType;//DataType可以是任何相应的数据类型如int,float或char
typedefstruct
{DataTypedata[ListSize];//向量data用于存放表结点
intlength;//当前的表长度
}SeqList;
voidmain（）
{
SeqListL;
inti,x;
intn=10;//欲建立的顺序表长度
L.length=0;
voidCreateList（SeqList*L,intn）;
voidPrintList（SeqListL,intn）;
intLocateList（SeqListL,DataTypex）;
voidInsertList（SeqList*L,DataTypex,inti）;
voidDeleteList（SeqList*L,inti）;
CreateList（&L,n）;//建立顺序表
PrintList（L,n）;//打印顺序表
printf（"输入要查找的值：
"）;
scanf（"%d",&x）;
i=LocateList（L,x）;//顺序表查找
printf（"输入要插入的位置：
"）;
scanf（"%d",&i）;
printf（"输入要插入的元素：
"）;
scanf（"%d",&x）;
InsertList（&L,x,i）;//顺序表插入
PrintList（L,n）;//打印顺序表
}printf（"输入要删除的位置：
"）;
scanf（"%d",&i）;
DeleteList（&L,i）;//顺序表删除
PrintList（L,n）;//打印顺序表
}
//顺序表的建立：
voidCreateList（SeqList*L,intn）
{
//在此插入必要的语句
}
//顺序表的打印：
voidPrintList（SeqListL,intn）
{
//在此插入必要的语句
}
//顺序表的查找：
intLocateList（SeqListL,DataTypex）
{
//在此插入必要的语句
}
//顺序表的插入：
voidInsertList（SeqList*L,DataTypex,inti）
{
//在此插入必要的语句
}
//顺序表的删除：
voidDeleteList（SeqList*L,inti）
{
//在此插入必要的语句
}
实验二、单链表（2学时）
1.验证实验
打开教材自带教学辅助光盘，进入光盘中的“\DSDemoC”目录，运行DSDemo.EXE，进入数据结构算法演示系统（C语言描述）V3.1C中文版。
具体操作请按照界面上的提示进行。
选择主菜单中链表下的各算法。
首先仔细阅读算法，再输入数据，分步运行算法，检验自己对算法的理解是否正确。
在实验报告中写出自己在演示算法过程中理解和实际运算的不同之处，并总结原因。
2.设计实验
设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求：
（1）从键盘输入20个整数，产生不带表头的单链表，并输入结点值。
（2）从键盘输入1个整数，在单链表中查找该结点的位置。
若找到，则显示“找到了”；否则，则显示“找不到”。
（3）从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。
（4）从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。
（5）将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。
（6）删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。
（7）把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。
（8）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。
3.实验报告
完成实验二实验报告。
要求同实验一。
提示：
可参考以下思路进行设计：
#include
#include
//单链表的定义：
typedefintDataType;//DataType可以是任何相应的数据类型如int,float或char
typedefstructnode//结点类型定义
{DataTypedata;//结点的数据域
structnode*next;//结点的指针域
}ListNode;
typedefListNode*LinkList;
voidmain（）
{
inti;
DataTypekey,x;
LinkListhead;
ListNode*p;
LinkListCreateList（void）;
voidPrintList（LinkListhead）;
LinkListLocateNode（LinkListhead,DataTypekey）;
LinkListGetNode（LinkListhead,inti）;
voidInsertList（LinkListhead,DataTypex,inti）;
voidDeleteList（LinkListhead,inti）;
voidDeleteManyList（LinkListhead）;
voidDeleteEvenList（LinkListhead）;
voidChangeCircList（LinkListhead）;
voidPrintCircList（LinkListhead）;
head=CreateList（）;//建立单链表
PrintList（head）;//打印单链表
printf（"输入要查找的值：
"）;
scanf（"%d",&key）;
p=LocateNode（head,key）;//单链表查找
printf（"请输入欲插入元素的位置：
"）;
scanf（"%d",&i）;
printf（"请输入欲插入的元素：
"）;
scanf（"%d",&x）;
InsertList（head,x,i）;//单链表插入
PrintList（head）;//打印单链表
printf（"请输入欲删除结点的位置：
"）;
scanf（"%d",&i）;
DeleteList（head,i）;//单链表删除
PrintList（head）;//打印单链表
DeleteManyList（head）;//删除重复值
PrintList（head）;//打印单链表
DeleteEvenList（head）;//删除偶数值
PrintList（head）;//打印单链表
ChangeCircList（head）;//修改为循环单链表
PrintCircList（head）;//打印循环单链表
/*voidDivideList（LinkListhead,LinkList*A,LinkList*B）;
//分割成两个单链表
DivideList（head,&A,&B）;
PrintList（A）;
PrintList（B）;
*/
}
//单链表的建立：
LinkListCreateList（void）
{
//在此插入必要的语句
}
//单链表的打印：
voidPrintList（LinkListhead）
{
//在此插入必要的语句
}
//单链表的查找1：
LinkListLocateNode（LinkListhead,DataTypekey）
{
//在此插入必要的语句
}
//单链表的查找2：
LinkListGetNode（LinkListhead,inti）
{
//在此插入必要的语句
}
//单链表的插入：
voidInsertList（LinkListhead,DataTypex,inti）
{
//在此插入必要的语句
}
//单链表的删除：
voidDeleteList（LinkListhead,inti）
{
//在此插入必要的语句
}
//删除单链表中重复值：
voidDeleteManyList（LinkListhead）
{
//在此插入必要的语句
}
//删除单链表中偶数值：
voidDeleteEvenList（LinkListhead）
{
//在此插入必要的语句
}
//修改为循环单链表：
voidChangeCircList（LinkListhead）
{
//在此插入必要的语句
}
//循环单链表的打印：
voidPrintCircList（LinkListhead）
{
//在此插入必要的语句
}
/*
//分割成两个单链表
voidDivideList（LinkListhead,LinkList*A,LinkList*B）;
{
//在此插入必要的语句
}
*/
实验三、栈和队列（4学时）
1.验证实验
打开教材自带教学辅助光盘，进入光盘中的“\DSDemoC”目录，运行DSDemo.EXE，进入数据结构算法演示系统（C语言描述）V3.1C中文版。
具体操作请按照界面上的提示进行。
分别选择主菜单中栈子菜单下的前三个算法和队列子菜单下的各算法。
首先仔细阅读算法，再输入数据，分步运行算法，检验自己对算法的理解是否正确。
在实验报告中写出自己在演示算法过程中理解和实际运算的不同之处，并总结原因。
2.应用实验
阅读所给的源程序，在实验报告中写出算法的功能和运行结果。
程序如下：
#defineMAXNUM100/*栈中最大元素个数*/
#defineN11/*地图的第一维长度*/
#include
#include
typedefstruct{
intx;/*行下标*/
inty;/*列下标*/
intd;/*运动方向*/
}DataType;
structSeqStack{/*顺序栈类型定义*/
intt;/*指示栈顶位置*/
DataTypes[MAXNUM];
};
typedefstructSeqStack*PSeqStack;/*顺序栈类型的指针类型*/
PSeqStackpastack;/*pastack是指向顺序栈的一个指针变量*/
PSeqStackcreateEmptyStack_seq（void）{
PSeqStackpastack;
pastack=（PSeqStack）malloc（sizeof（structSeqStack））;
if（pastack==NULL）
printf（"Outofspace!
!
\n"）;
else
pastack->t=-1;
returnpastack;
}
intisEmptyStack_seq（PSeqStackpastack）{
returnpastack->t==-1;
}
/*在栈中压入一元素x*/
voidpush_seq（PSeqStackpastack,DataTypex）{
if（pastack->t>=MAXNUM-1）
printf（"Overflow!
\n"）;
else{
pastack->t++;
pastack->s[pastack->t]=x;
}
}
/*删除栈顶元素*/
voidpop_seq（PSeqStackpastack）{
if（pastack->t==-1）
printf（"Underflow!
\n"）;
else
pastack->t--;
}
/*当pastack所指的栈不为空栈时，求栈顶元素的值*/
DataTypetop_seq（PSeqStackpastack）{
return（pastack->s[pastack->t]）;
}
voidpushtostack（PSeqStackst,intx,inty,intd）{
DataTypeelement;
element.x=x;
element.y=y;
element.d=d;
push_seq（st,element）;
}
voidprintpath（PSeqStackst）{
DataTypeelement;
printf（"Thereverspathis:
\n"）;/*打印路径上的每一点*/
while（!
isEmptyStack_seq（st））{
element=top_seq（st）;
pop_seq（st）;
printf（"thenodeis:
%d%d\n",element.x,element.y）;
}
}
/*迷宫maze[M][N]中求从入口maze[x1][y1]到出口maze[x2][y2]的一条路径*/
/*其中1<=x1,x2<=M-2,1<=y1,y2<=N-2*/
voidmazePath（intmaze[][N],intdirection[][2],intx1,inty1,intx2,inty2）{
inti,j,k,g,h;
PSeqStackst;
DataTypeelement;
st=createEmptyStack_seq（）;
maze[x1][y1]=2;/*从入口开始进入,作标记*/
pushtostack（st,x1,y1,-1）;/*入口点进栈*/
while（!
isEmptyStack_seq（st））{/*走不通时,一步步回退*/
element=top_seq（st）;
pop_seq（st）;
i=element.x;j=element.y;
for（k=element.d+1;k<=3;k++）{/*依次试探每个方向*/
g=i+direction[k][0];h=j+direction[k][1];
if（g==x2&&h==y2&&maze[g][h]==0）{/*走到出口点*/
printpath（st）;/*打印路径*/
return;
}
if（maze[g][h]==0）{/*走到没走过的点*/
maze[g][h]=2;/*作标记*/
pushtostack（st,i,j,k）;/*进栈*/
i=g;j=h;k=-1;/*下一点转换成当前点*/
}
}
}
printf（"Thepathhasnotbeenfound.\n"）;/*栈退完未找到路径*/
}
intmain（）{
intdirection[][2]={0,1,1,0,0,-1,-1,0};
intmaze[][N]={
1,1,1,1,1,1,1,1,1,1,1,
1,0,1,0,0,1,1,1,0,0,1,
1,0,0,0,0,0,1,0,0,1,1,
1,0,1,1,1,0,0,0,1,1,1,
1,0,0,0,1,0,1,1,0,1,1,
1,1,0,0,1,0,1,1,0,0,1,
1,1,1,0,0,0,0,0,0,0,1,
1,1,1,1,1,1,1,1,1,1,1
};
mazePath（maze,direction,1,1,6,9）;
getchar（）;
return0;
}
3.应用实验
阅读所给的源程序，在实验报告中写出该程序的功能和运行结果。
（最好能写出每个子函数功能，以及重要语句的注释）
程序如下：
#include"stdio.h"
#defineNULL0
#defineERROR0
#defineOK1
#defineOVERFLOW0
#defineSTACK_INIT_SIZE2
typedefstruct
{
charlabel;
floattime;
}Car,Car2;
typedefstruct
{
Car*top;
Car*base;
intstacksize;
}SqStack;
intInitStack（SqStack*S）
{
S->base=（Car*）malloc（STACK_INIT_SIZE*sizeof（Car））;
if（!
（S->base））returnERROR;
S->top=S->base;
S->stacksize=STACK_INIT_SIZE;
returnOK;
}
intStackEmpty（SqStackS）
{
if（S.top==S.base）
returnOK;
else
returnERROR;
}
intStackFull（SqStackS）
{
if（S.top-S.base>=STACK_INIT_SIZE）
returnOK;
else
returnERROR;
}
intPush（SqStack*S,Care）
{
if（S->top-S->base>=STACK_INIT_SIZE）
returnOVERFLOW;
else
{
*（S->top++）=e;
returnOK;
}
}
intPop（SqStack*S,Car*e）
{
if（S->top==S->base）
returnERROR;
*e=*（--（S->top））;
}
typedefstruct
{
Car2*top2;
Car2*base2;
intstacksize2;
}SqStack2;
intInitStack2（SqStack2*S2）
{
S2->base2=（Car2*）malloc（STACK_INIT_SIZE*sizeof（Car2））;
if（!
（S2->top2））returnERROR;
S2->top2=S2->base2;
S2->stacksize2=STACK_INIT_SIZE;
returnOK;
}
intPush2（SqStack2*S2,Car2e2）
{
if（S2->top2-S2->base2>=STACK_INIT_SIZE）
returnOVERFLOW;
*（S2->top2++）=e2;
returnOK;
}
intPop2（SqStack2*S2,Car2*e2）
{
if（S2->top2==S2->base2）
exit（OVERFLOW）;
*e2=*（--（S2->top2））;
returnOK;
}
intStackEmpty2（SqStack2S2）
{
if（S2.top2==S2.base2）
returnOK;
else
returnERROR;
}
typedefstructQNode
{
Cardata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct
{
QueuePtrfront;
QueuePtrrear;
}LinkQueue;
intInitQueue（LinkQueue*Q）
{
Q->front=Q->rear=（QueuePtr）malloc（sizeof（QNode））;
if（!
（Q->front））returnERROR;
Q->front->next=NULL;
returnOK;
}
intEnQueue（LinkQueue*Q,Care）
{
QueuePtrp;
p=（QueuePtr）malloc（sizeof（QNode））;
if（!
p）returnERROR;
p->data=e;
p->next=NULL;
Q->rear->next=p;
Q->rear=p;
returnOK;
}
intQueueEmpty（LinkQueueQ）
{
if（Q.front==Q.rear）
returnOK;
else
returnERROR;
}
intDeQueue（LinkQueue*Q,Car*e）
{
QueuePtrp;
if（Q->front==Q->rear）returnERROR;
p=Q->front->next;
*e=p->data;
Q->front->next=p->next;
if（Q->rear==p
升级会员 