桂电数据结构实验报告.docx
《桂电数据结构实验报告.docx》由会员分享，可在线阅读，更多相关《桂电数据结构实验报告.docx（28页珍藏版）》请在冰豆网上搜索。
桂电数据结构实验报告
实验二栈和队列及应用
一、实验目的
1.掌握用c语言实现队列和栈的方法
2.了解栈和队列的使用
二、实验内容
实验题目一
在许多语言现象中，常见到一种形如abcba的文字，这种文字从左到右读和从右到左读结果是一样的，这种文字就是常说的回文。
设计一个程序可以判断给定的一个文字是否是回文。
注意：
在本实验中，要求在实现上面的题目时，必须使用如下算法：
考虑到栈的先进后出以及队列的后进先出，可以结合这两种结构来实现需要的功能，即将文字分别入队和入栈，然后依次通过出队和出栈输出判断是否有不相同的字符，一旦发现就证明文字不是一个回文。
实验步骤：
第一步：
编写程序，实现栈，该栈可以用数组实现，也可以用链表实现
第二步：
编写程序，实现队列，该队列可以为循环队列，也可以用链表实现
第三步：
编写主算法，使用自己编写的栈和队列实现回文判断问题（通过键盘输入一个以＃结束的字符串，进行判断）
#include
#include
structNode;
typedefstructNode*PNode;
structNode
{
charinfo;
PNodelink;
};
structLinkStack//定义栈
{
PNodetop;
};
typedefstructLinkStack*PLinkStack;
structLinkQuene//定义队列
{
PNodef;
PNoder;
};
typedefstructLinkQuene*PLink;
PLinkStackCreateStackLink（）//创建空栈
{
PLinkStackptop;
ptop=（PLinkStack）malloc（sizeof（structLinkStack））;
if（ptop==NULL）
{
printf（"申请空间失败！
\n"）;
exit（-1）;
}
ptop->top=NULL;
returnptop;
}
PLinkCreateLink（）//创建空队列
{
PLinkpl;
pl=（PLink）malloc（sizeof（structLinkQuene））;
if（pl==NULL）
{
printf（"申请空间失败！
\n"）;
exit（-1）;
}
pl->f=NULL;
pl->r=NULL;
returnpl;
}
voidPushLink（PLinkStackpl,charc）//进栈
{
PNodep;
p=（PNode）malloc（sizeof（structNode））;
if（p==NULL）
{
printf（"申请空间失败！
\n"）;
exit（-1）;
}
p->info=c;
p->link=pl->top;
pl->top=p;
}
voidPushQuene（PLinkpl,charc）//进队列
{
PNodep;
p=（PNode）malloc（sizeof（structNode））;
if（p==NULL）
{
printf（"申请空间失败！
\n"）;
exit（-1）;
}
p->info=c;
p->link=NULL;
if（pl->f==NULL）
pl->f=p;
else
pl->r->link=p;
pl->r=p;
}
voidGetLink（PLinkStackpl）//出栈
{
PNodep;
p=（PNode）malloc（sizeof（structNode））;
if（pl->top==NULL）
{
printf（"空栈！
\n"）;
exit（-1）;
}
if（p==NULL）
{
printf（"申请空间失败！
\n"）;
exit（-1）;
}
p=pl->top;
pl->top=pl->top->link;
free（p）;
}
voidGetQuene（PLinkpl）//出队列
{
PNodep;
p=（PNode）malloc（sizeof（structNode））;
if（pl->f==NULL）
{
printf（"空队列！
\n"）;
exit（-1）;
}
if（p==NULL）
{
printf（"申请空间失败！
\n"）;
exit（-1）;
}
p=pl->f;
pl->f=p->link;
free（p）;
}
charGetLinkData（PLinkStackpl）//获得栈顶数值
{
if（pl->top==NULL）
{
printf（"空栈！
\n"）;
exit（-1）;
}
returnpl->top->info;
}
charGetQueneData（PLinkpl）//获得队列头部数值
{
if（pl->f==NULL）
{
printf（"空队列！
\n"）;
exit（-1）;
}
returnpl->f->info;
}
voidPrintLink（PLinkStackpl）//打印栈
{
PNodep;
p=（PNode）malloc（sizeof（structNode））;
if（p==NULL）
{
printf（"申请空间失败！
\n"）;
exit（-1）;
}
p=pl->top;
while（p->link!
=NULL）
{
printf（"%c=>",p->info）;
p=p->link;
}
printf（"%c\n",p->info）;
}
voidPrintQuene（PLinkpl）//打印队列
{
PNodep;
p=（PNode）malloc（sizeof（structNode））;
if（p==NULL）
{
printf（"申请空间失败！
\n"）;
exit（-1）;
}
p=pl->f;
while（p->link!
=pl->r->link）
{
printf（"%c=>",p->info）;
p=p->link;
}
printf（"%c\n",p->info）;
}
intmain（）
{
//charch[]="abcdcba";
inti;
chars1,s2,x;
PLinkStackpl1;
PLinkpl2;
pl1=CreateStackLink（）;
pl2=CreateLink（）;
printf（"请输入（以#结束）：
\n"）;
for（i=0;i<50;i++）
{
scanf（"%c",&x）;
if（x=='#'）
break;
PushLink（pl1,x）;
PushQuene（pl2,x）;
}
printf（"栈输出为：
"）;
PrintLink（pl1）;
//s=GetLinkData（pl1）;
//printf（"%c\n",s）;
printf（"队列输出为：
"）;
PrintQuene（pl2）;
//s=GetQueneData（pl2）;
//printf（"%c\n",s）;
while（pl1->top!
=NULL&&pl2->f!
=NULL）
{
s1=GetLinkData（pl1）;
s2=GetQueneData（pl2）;
if（s1==s2）
{
GetLink（pl1）;
GetQuene（pl2）;
}
else
{
printf（"不是回文数！
\n"）;
break;
}
}
if（pl2->f==NULL）
{
printf（"这是回文数！
\n"）;
}
return0;
}
实验三树及应用
一、实验目的
1、掌握简单的二叉树编程，掌握二叉树构造的一些方法
2、掌握二叉树的中序，前序，后序遍历方法
二、实验内容
实验题目一：
（1）从键盘输入任意二叉树的前根排序序列，用＃结束，当某节点的左子树或右子树为空时，用“@”代替，
例如对于如下图的二叉树，输入内容为：
abd@@eh@@@cf@i@@g@@#
（2）分别用三种遍历方法输出遍历结果。
（3）键盘输入一个值x，要求在生成好的二叉排序树中查找这个值x，如果找到，则输出“找到了”，没有找到，则输出“没有找到”
#include
#include
#include
#include
typedefcharDataType;
structBinNode
{
DataTypeinfo;
BinNode*lchild;
BinNode*rchild;
};
typedefBinNode*BinTree;
voidInitBinTree（BinTree&T）;
voidCreateBinTree（BinTree&T）;
voidDisplayBinTree_DLR（BinTree&T）;
voidDisplayBinTree_LRD（BinTree&T）;
voidDisplayBinTree_LDR（BinTree&T）;
intServechBinTree（DataTypex,BinTree&T）;
intmain（）
{
BinTreeT;
printf（"1:
初始化树\n2:
先根序列创建树\n3:
后根序列输出\n4:
中根序列输出\n5:
先根序列输出\n6:
查找\n"）;
for（;;）
{
//printf（"1:
初始化树\n2:
先根序列创建树\n3:
后根序列输出\n4:
中根序列输出\n5:
先根序列输出\n6:
查找\n"）;
inti;
printf（"请输入你的选择：
\n"）;
cin>>i;
if（i==1）
InitBinTree（T）;
elseif（i==2）
CreateBinTree（T）;
elseif（i==3）
{
printf（"后根序列输出:
"）;
DisplayBinTree_LRD（T）;
printf（"\n"）;
}
elseif（i==4）
{
printf（"中根序列输出:
"）;
DisplayBinTree_LDR（T）;
printf（"\n"）;
}
elseif（i==5）
{
printf（"先根序列输出:
"）;
DisplayBinTree_DLR（T）;
printf（"\n"）;
}
elseif（i==6）
{
DataTypex;
printf（"请输入要查找的元素：
\n"）;
cin>>x;
if（ServechBinTree（x,T）==1）
printf（"%chavefind!
!
!
\n",x）;
else
printf（"nofind!
!
!
\n"）;
}
}
return0;
}
voidInitBinTree（BinTree&T）
{
T=（BinTree）malloc（sizeof（structBinNode））;
if（T!
=NULL）
printf（"Initatreesuccessful!
!
\n"）;
else
printf（"Initatreefailt!
!
!
\n"）;
}
voidCreateBinTree（BinTree&T）
{
DataTypech;
scanf（"%c",&ch）;
if（ch=='@'）
T=NULL;
else
{
T=（BinTree）malloc（sizeof（structBinNode））;
if（T==NULL）
exit（0）;
T->info=ch;
CreateBinTree（T->lchild）;
CreateBinTree（T->rchild）;
}
}
voidDisplayBinTree_DLR（BinTree&T）//先根
{
if（T!
=NULL）
{
printf（"%c",T->info）;
DisplayBinTree_DLR（T->lchild）;
DisplayBinTree_DLR（T->rchild）;
}
}
voidDisplayBinTree_LRD（BinTree&T）//后根
{
if（T!
=NULL）
{
DisplayBinTree_LRD（T->lchild）;
DisplayBinTree_LRD（T->rchild）;
printf（"%c",T->info）;
}
}
voidDisplayBinTree_LDR（BinTree&T）//中根
{
if（T!
=NULL）
{
DisplayBinTree_LDR（T->lchild）;
printf（"%c",T->info）;
DisplayBinTree_LDR（T->rchild）;
}
}
intServechBinTree（DataTypex,BinTree&T）
{
if（T!
=NULL）
{
if（T->info==x）
return1;
else
{
if（ServechBinTree（x,T->lchild）==1）
return1;
else
returnServechBinTree（x,T->rchild）;
}
}
}
实验四查找
一、实验目的
掌握折半查找法
二、实验内容
设一数组，存放有10个排好顺序的整数，要求键盘输入一个值，然后使用折半查找的方法在此排好顺序的数组中查找出该值，并输入该值的所在的数组下标。
要求：
（1）自己编写函数实现折半查找算法
（2）要实现完整的程序，包括输入输出
输入要查找的值，假如该值在数组中不存在，输出“没有找到”，否则输出该值在数组中的位置
#include
intHalfSearch（ints,int*sum,intfirst,intlast）
{
intmid;
mid=（first+last）/2;
if（first>last）
return-1;
else
{
if（sum[mid]==s）
returnmid;
elseif（sreturnHalfSearch（s,sum,first,mid-1）;
elseif（s>sum[mid]）
returnHalfSearch（s,sum,mid+1,last）;
}
}
intmain（）
{
intsum[]={1,2,3,4,5,6,7,8,9,10,11,12};
ints,r;
printf（"请输入一个数字进行查询：
"）;
scanf（"%d",&s）;
r=HalfSearch（s,sum,0,11）;
if（r==-1）
printf（"没有查找到%d！
",s）;
else
printf（"%d在第%d个位置！
",s,r）;
return0;
}
实验五排序
一、实验目的
掌握快速排序
二、实验要求
复习排序方法，掌握快速排序算法，并自己编写代码实现
三、实验内容
编写程序，实现快速排序。
从键盘上输入10个整数，存放在数组中，然后用快速排序法对其从小到大进行排序，并输出排序结果。
思考：
书上已经有的部分快速排序程序，实际上对数据进行的是从小到大的排序，假如，需要将数据从大到小进行排序，该如何做？
#include
#include
#include
typedefintKeyType;
typedefintDataType;
typedefstruct{
KeyTypekey;
//DataTypeinfo;
}RecordNode;
typedefstruct{
intn;
RecordNode*record;
}SortObject;
voidInser（SortObject*sj）;
voidQuickSort（SortObject*pvector,intl,intr）;
SortObject*Init（intn）;
voiddisplay（SortObject*pvector）;
intmain（）
{
//intk;
//inti;
SortObject*sj=Init（10）;
Inser（sj）;
printf（"beforsort:
\n"）;
display（sj）;
QuickSort（sj,0,9）;
printf（"\naftersort:
\n"）;
display（sj）;
return0;
}
voiddisplay（SortObject*pvector）
{
for（inti=0;i<10;i++）
{
printf（"%d",pvector->record[i].key）;
}
}
SortObject*Init（intn）
{
SortObject*sj=（SortObject*）malloc（sizeof（SortObject））;
sj->record=（RecordNode*）malloc（sizeof（RecordNode）*n）;
sj->n=n;
returnsj;
}
voidInser（SortObject*sj）
{
inti;
KeyTypek;
//sj->record=（RecordNode*）malloc（sizeof（int）*sj->n）;
//fflush（stdin）;
for（i=0;in;i++）
{
scanf（"%d",&k）;
sj->record[i].key=k;
}
}
voidQuickSort（SortObject*pvector,intl,intr）
{
inti,j;
RecordNodetemp;
if（l>=r）
return;
i=l;
j=r;
temp=pvector->record[i];
while（i!
=j）
{
while（（irecord[j].key>temp.key）
j--;
if（ipvector->record[i++]=pvector->record[j];
while（（irecord[i].keyi++;
if（ipvector->record[j--]=pvector->record[i];
}
pvector->record[i]=temp;
QuickSort（pvector,l,i-1）;
QuickSort（pvector,i+1,r）;
}
实验六图
一、实验目的
熟悉图的遍历操作
二、实验内容
采用邻接矩阵作为存储结构，完成无向图的深度优先遍历和广度优先遍历
具体的实验代码包括
1）读入图，保存为邻接矩阵的形式，为了方便，可以直接读入一个矩阵，也可以让用户输入两条相连的边，或者读入相邻的两个结点
2）实现深度优先遍历的算法
3）输出深度优先遍历的结果
4）实现广度优先遍历的算法
5）输出广度优先遍历的结果
如上图：
从点1开始的深度遍历输出为：
1→2→4→8→5→3→6→7
从点1开始的广度遍历输出为：
1→2→3→4→5→6→7→8
//图的遍历算法程序
//图的遍历是指按某条搜索路径访问图中每个结点，使得每个结点均被访问一次，而且仅被访问一次。
图的遍历有深度遍历算法和广度遍历算法，程序如下：
#include
//#include
#defineINFINITY32767
#defineMAX_VEX20//最大顶点个数
#defineQUEUE_SIZE（MAX_VEX+1）//队列长度
usingnamespacestd;
bool*visited;//访问标志数组
//图的邻接矩阵存储结构
typedefstruct{
char*vexs;//顶点向量
intarcs[MAX_VEX][MAX_VEX];//邻接矩阵
intvexnum,arcnum;//图的当前顶点数和弧数
}Graph;
//队列类
classQueue{
public:
voidInitQueue（）{
base=（int*）malloc（QUEUE_SIZE*sizeof（int））;
front=rear=0;
}
voidEnQueue（inte）{
base[rear]=e;
rear=（rear+1）%QUEUE_SIZE;
}
voidDeQueue（int&e）{
e=base[front];
front=（front+1）%QUEUE_SIZE;
}
public:
int*base;
intfront;
intrear;
};
//图G中查找元素c的位置
intLocate（GraphG,charc）{
for（inti=0;iif（G.vexs[i]==c）returni;
return-1;
}
//创建无向网
voidCre
升级会员 