DATASTRUCTWord格式.docx
《DATASTRUCTWord格式.docx》由会员分享，可在线阅读，更多相关《DATASTRUCTWord格式.docx（23页珍藏版）》请在冰豆网上搜索。
软件：
配有Windows98/2000/XP操作系统，安装VisualC++。
5、实验时间：
10学时
6、该文档的文件名不要修改，存入<
学号>
<
姓名>
命名的文件夹中
7、该表中的数据只需填空，已有内容不要修改
实验结果（运行结果界面及源程序，运行结果界面放在前面）：
#include"
stdafx.h"
iostream.h"
string.h"
enumStatus{OK=1,ERROR=0};
typedefstruct
{
charname[8];
intnumber;
}team;
structBinaryTreeNode
teamdata;
BinaryTreeNode*LChild;
BinaryTreeNode*RChild;
};
structSType
BinaryTreeNode*ptr;
boolB;
structQType
BinaryTreeNode*qtr;
structStack
SType*element;
inttop;
intMaxSize;
structQueue
QType*element;
intfront;
intrear;
voidCreatStack（Stack&
S,int&
MaxStackSize）
{//构造一个最大容量为MaxStackSize的堆栈S
S.MaxSize=MaxStackSize;
S.element=newSType[S.MaxSize];
S.top=-1;
}
boolIsEmpty（Stack&
S）
{//判断堆栈S是否为空
if（S.top==-1）returntrue;
returnfalse;
boolIsFull（Stack&
{//判断堆栈S是否为满
if（S.top>
=S.MaxSize-1）returntrue;
StatusPush（Stack&
S,SType&
x）
{//x进S栈，返回进栈后的状态值
if（IsFull（S））returnERROR;
S.top++;
S.element[S.top]=x;
returnOK;
StatusPop（Stack&
{//将S栈顶的值取至x中，返回出栈后的状态值
if（IsEmpty（S））returnERROR;
x=S.element[S.top];
S.top--;
voidCreatQueue（Queue&
Q,int&
MaxQueueSize）
{//构造一个最大容量为MaxQueueSize的队列Q
Q.MaxSize=MaxQueueSize;
Q.element=newQType[Q.MaxSize+1];
Q.front=0;
Q.rear=0;
boolIsEmpty（Queue&
Q）
{//判断队列Q是否为空
if（Q.front==Q.rear）returntrue;
boolIsFull（Queue&
{//判断队列Q是否为满
if（Q.front==（Q.rear+1）%（Q.MaxSize+1））returntrue;
StatusEnqueue（Queue&
Q,QType&
{//x进Q队列，返回进队后的状态值
if（IsFull（Q））returnERROR;
Q.element[Q.rear]=x;
Q.rear=（Q.rear+1）%（Q.MaxSize+1）;
StatusDequeue（Queue&
{//将Q队列队头的值取至x中，返回出队后的状态值
if（IsEmpty（Q））returnERROR;
x=Q.element[Q.front];
Q.front=（Q.front+1）%（Q.MaxSize+1）;
voidPreOrder（BinaryTreeNode*BT）
{//二叉树的前序遍历递归算法
if（BT）
{
cout<
<
BT->
data.name<
"
:
data.number<
"
;
//访问二叉树的结点
PreOrder（BT->
LChild）;
RChild）;
}
voidInOrder（BinaryTreeNode*BT）
{//二叉树的中序遍历递归算法
InOrder（BT->
voidPostOrder（BinaryTreeNode*BT）
{//二叉树的后序遍历递归算法
PostOrder（BT->
voidPreOrderN（BinaryTreeNode*BT）
{//二叉树的前序遍历非递归算法
StackS;
STypeT;
T.ptr=BT;
intMaxStackSize=50;
CreatStack（S,MaxStackSize）;
while（T.ptr||!
IsEmpty（S））
if（T.ptr）
{
cout<
T.ptr->
//访问"
根"
结点
Push（S,T）;
//根结点指针进栈，以后回溯时再退栈
T.ptr=T.ptr->
LChild;
//指针指向访问过的"
结点左子树
}
else//左子树为空时，利用堆栈回溯
if（!
{
Pop（S,T）;
//从堆栈中弹出回溯结点指针（该结点已访问过）
T.ptr=T.ptr->
RChild;
//指针指向回溯结点的右子树
}
delete[]S.element;
voidInOrderN（BinaryTreeNode*BT）
{//二叉树的中序遍历非递归算法
do
while（T.ptr）
{//找最左子树
//"
结点（未访问）指针进栈，以后回溯时再退栈
//指针指向"
if（!
{//左子树为空时，利用堆栈回溯
Pop（S,T）;
//从堆栈中弹出回溯结点指针（该结点未访问过）
while（（T.ptr）||!
IsEmpty（S））;
voidPostOrderN（BinaryTreeNode*BT）
{//二叉树的后序遍历非递归算法
BinaryTreeNode*p=BT;
STypetemp;
while（（p）||!
if（p）
temp.B=false;
//准备进栈的结点进栈标志设为第一次进栈
temp.ptr=p;
Push（S,temp）;
//根结点（未访问）指针及标志进栈，以后回溯时再退栈
p=p->
//指针指向该"
else
{//左子树为空时，利用堆栈回溯
Pop（S,temp）;
//从堆栈中弹出回溯结点指针及标志（该结点未访问过）
p=temp.ptr;
//p指向退栈结点，否则p的值是空
if（temp.B）
{
cout<
p->
//访问该结点
p=NULL;
//将p设为空的目的是为强制退栈作准备
}
else
temp.B=true;
//改变进栈标志，准备重新进栈
Push（S,temp）;
p=p->
的右子树
voidLevelOrderTL（BinaryTreeNode*BT）
{//从左至右，从上至下按层次遍历一棵二叉树（Top_Left）
QueueQ;
QTypeD;
D.qtr=BT;
BinaryTreeNode*q;
intMaxQueueSize=50;
CreatQueue（Q,MaxQueueSize）;
//产生一个空队列，这一过程函数可以不在这里进行
while（D.qtr）
D.qtr->
q=D.qtr;
if（D.qtr->
LChild）
D.qtr=D.qtr->
Enqueue（Q,D）;
//左子树进队
D.qtr=q;
RChild）
//右子树进队
Dequeue（Q,D））return;
//出队返回状码ERROR时结束（队空）
delete[]Q.element;
voidLevelOrderTR（BinaryTreeNode*BT）
{//从右至左，从上至下按层次遍历一棵二叉树（Top_Right）
BinaryTreeNode*MakeNode（team&
{//构造结点
ptr=newBinaryTreeNode;
if（!
ptr）returnNULL;
ptr->
data=x;
LChild=NULL;
RChild=NULL;
returnptr;
voidMakeBinaryTree（BinaryTreeNode*root,BinaryTreeNode*left,BinaryTreeNode*right）
{//联接root，left，right所指的结点指针为二叉树
root->
LChild=left;
RChild=right;
intBinaryHeight（BinaryTreeNode*BT）
{//返回二叉树的高度
BT）return0;
intHighL=BinaryHeight（BT->
intHighR=BinaryHeight（BT->
if（HighL>
HighR）
return++HighL;
else
return++HighR;
voidBinaryDelete（BinaryTreeNode*BT）
{//二叉树的删除算法
BinaryDelete（BT->
deleteBT;
//这里的delete是系统过程
voidmain（）
BinaryTreeNode*p[11];
intm=2;
teamx[11];
cout<
********TheteamofInformationmanagementandinformationsystem0904********\n"
Pleaseinputtheinformationoftheteam:
\n"
/*for（inti=1;
i<
=10;
i++）//输入、构造结点
Player"
\nName:
cin>
>
x[i].name;
Number:
x[i].number;
p[i]=MakeNode（x[i]）;
}*/
chara[11][11]={"
"
ding"
cai"
liu"
xuan"
wu"
zhu"
yang"
jiang"
liao"
zhou"
intb[11]={0,14,24,3,11,10,5,1,8,17,21};
for（inti=1;
i++）
strcpy（x[i].name,a[i]）;
x[i].number=b[i];
for（i=1;
=5;
i++）//构造二叉树
if（i==5）
p[i]->
LChild=p[2*i];
}
else
MakeBinaryTree（p[i],p[2*i],p[2*i+1]）;
//输出二叉树的结构
Thebinarytreeis:
____________"
x[1].name<
x[1].number<
______________"
endl;
_______"
x[2].name<
x[2].number<
________"
x[3].name<
x[3].number<
___"
_"
x[4].name<
x[4].number<
__"
x[5].name<
x[5].number<
<
x[6].name<
x[6].number<
x[7].name<
x[7].number<
x[8].name<
x[8].number<
x[9].name<
x[9].number
x[10].name<
x[10].number<
//前序递归遍历
Theresultofpreorderrecursivetraversal:
PreOrder（p[1]）;
endl<
//中序递归遍历
cout<
Theresultofinorderrecursivetraversal:
InOrder（p[1]）;
//后序递归遍历
Theresultofpostorderrecursivetraversal:
PostOrder（p[1]）;
//前序非递归遍历
Theresultofpretordernon-recursivetraversal:
PreOrderN（p[1]）;
//中序非递归遍历
Theresultofinordernon-recursivetraversal:
InOrderN（p[1]）;
//后序非递归遍历
Theresultofpostordernon-recursivetraversal:
PostOrderN（p[1]）;
//层次遍历从上至下、从左至右
Theresultofleveltraversalfromuptodownfromlefttoright:
LevelOrderTL（p[1]）;
//层次遍历从上至下、从右至左
Theresultofleveltraversalfromuptodownfromrighttoleft:
LevelOrderTR（p[1]）;
//二叉树高度
TheheightoftheBinarytreeis:
BinaryHeight（p[1]）<
//删除
BinaryDelete（p[1]）;
实验四堆栈及队列的应用
一、【实验目的】
1、掌握链式堆栈的类型定义方法。
2、掌握链式堆栈上实现的几种基本操作。
3、掌握链式队列的类型定义方法。
4、掌握链式队列上实现的几种基本操作。
二、【实验内容】
1、编程序判断一个字符序列是否是回文，要求采用链式队列和链式堆栈。
（可参照书本例3-3）
（以下是程序部分代码，请调试并补充使之正确运行。
）
LinStack.h
typedefstructsnode
DataTypedata;
structsnode*next;
}LSNode;
voidStackInitiate（LSNode**head）
/*初始化带头结点链式堆栈*/
if（（*head=（LSNode*）malloc（sizeof（LSNode）））==NULL）
Printf（“没有空间申请\n”）;
Return;
（*head）->
next=NULL;
intStackNotEmpty（LSNode*head）
/*判堆栈是否非空，非空返回1；
空返回0*/
if（head->
next==NULL）return0;
elsereturn1;
intStackPush（LSNode*head,DataTypex）
/*把数据元素x插入链式堆栈head的栈顶作为新的栈顶*/
LSNode*p;
if（（p=（LSNode*）malloc（sizeof（LSNode）））==NULL）
printf（"
内存空间不足无法插入!
\n"
）;
return0;
data=x;
next=head->
next;
/*新结点链入栈顶*/
head->
next=p;
/*新结点成为新的栈顶*/
return1;
intStackPop（LSNode*head,DataType*d）
/*出栈并把栈顶元素由参数d带回*/
LSNode*p=head->
if（p==NULL）
堆栈已空出错！
next=p->
/*删除原栈顶结点*/
升级会员 