实验11二叉树的进一步操作.docx
《实验11二叉树的进一步操作.docx》由会员分享，可在线阅读，更多相关《实验11二叉树的进一步操作.docx（13页珍藏版）》请在冰豆网上搜索。
实验11二叉树的进一步操作
浙江大学城市学院实验报告
课程名称数据结构基础
实验项目名称实验十一二叉树的进一步操作
学生姓名专业班级学号
实验成绩指导老师（签名）日期
一.实验目的和要求
1、熟练掌握二叉树二叉链表的存储结构。
2、进一步掌握在二叉链表上的二叉树操作的实现原理与方法。
3、掌握中序遍历的非递归算法。
二.实验内容
1、实现以下说明的操作函数，添加到实验十所写的头文件binary_tree.h中，并建立主函数文件test4_2.cpp，编写测试语句加以验证。
操作函数如下：
①voidInOrder2（BTreeNode*BT）;
//非递归中序遍历二叉树BT
②voidChangeBTree（BTreeNode*&BT）;
//将二叉树中的所有结点的左右子树进行交换：
③IntCountBTree（BTreeNode*BT）;
//统计二叉树中的所有结点数并返回
④BTreeNode*CopyBTree（BTreeNode*BT）;
//复制一棵二叉树，并返回复制得到的二叉树根结点指针
2、选做：
实现以下说明的操作函数，添加到头文件binary_tree.h中，并在主函数文件test4_2.cpp中添加相应语句进行测试。
①intSimilarTrees（BTreeNode*BT1，BTreeNode*BT2）
//判断两棵二叉树是否相似。
所谓相似是指如果两棵二叉树具有相同的树型，则称它们是相似的，否则不是。
②BTreeNode*RemoveLeaves（BTreeNode*BT1）
//摘树叶：
摘除一棵二叉树上的所有叶子结点后返回一棵新的二叉树。
3、填写实验报告，实验报告文件取名为report11.doc。
4、上传实验报告文件report11.doc、源程序文件test4_2.cpp及binary_tree.h到Ftp服务器上自己的文件夹下。
三.函数的功能说明及算法思路
（包括每个函数的功能说明，及一些重要函数的算法实现思路）
四.实验结果与分析
五.心得体会
【附录----源程序】
test4_2.cpp
#include
#include
#include
typedefcharElemType;
#include"binary_tree.h"
voidmain（）
{
BTreeNode*BT1,*BT2;
InitBTree（BT1）;
InitBTree（BT2）;
cout<<"请输入二叉树BT1：
"<CreatBTree（BT1）;
getchar（）;
PrintBTree（BT1,1）;
cout<cout<<"请输入二叉树BT2：
"<CreatBTree（BT2）;
PrintBTree（BT2,1）;
cout<if（SimilarTrees（BT1,BT2））
cout<<"二叉树BT1与BT2相似"<else
cout<<"二叉树BT1与BT2不相似"<cout<<"先序遍历二叉树BT1：
";
PreOrder2（BT1）;
cout<<"中序遍历二叉树BT1：
";
InOrder2（BT1）;
cout<<"层序遍历二叉树BT1：
";
LevelOrder2（BT1）;
cout<<"二叉树BT1的结点数：
"<cout<<"交换二叉树BT1所有结点的左右子树：
"<ChangeBTree（BT1）;
PrintBTree（BT1,1）;
cout<cout<<"摘树叶：
摘除二叉树BT1的所有叶子结点"<RemoveLeaves（BT1）;
PrintBTree（BT1,1）;
cout<ClearBTree（BT1）;
ClearBTree（BT2）;
}
binary_tree.h
structBTreeNode{
ElemTypedata;
BTreeNode*left;
BTreeNode*right;
};
#include"BTreeStack.h"
#include"BTreeQueue.h"
voidInitBTree（BTreeNode*&BT）
{
BT=NULL;
}
voidCreatBTree（BTreeNode*&BT）
{
charch;
ch=getchar（）;
if（ch=='$'）
BT=NULL;
else{
if（!
（BT=（BTreeNode*）malloc（sizeof（BTreeNode））））
exit
（1）;
BT->data=ch;
CreatBTree（BT->left）;
CreatBTree（BT->right）;
}
}
intEmptyBTree（BTreeNode*BT）
{
returnBT==NULL;
}
voidPrintBTree（BTreeNode*BT,intn）
{
inti;
if（BT==NULL）
return;
PrintBTree（BT->right,n+1）;
for（i=0;icout<<"";
cout<<"---";
cout<data<PrintBTree（BT->left,n+1）;
}
voidClearBTree（BTreeNode*&BT）
{
if（BT!
=NULL）{
ClearBTree（BT->left）;
ClearBTree（BT->right）;
deleteBT;
BT=NULL;
}
}
/*非递归先序遍历二叉树BT*/
voidPreOrder2（BTreeNode*BT）
{
StackS;
InitStack（S）;
BTreeNode*p=BT;
while（p!
=NULL||!
EmptyStack（S））{
while（p!
=NULL）{
cout<data<<'';
Push（S,p）;
p=p->left;
}
if（!
EmptyStack（S））{
p=Pop（S）;
p=p->right;
}
}
cout<ClearStack（S）;
}
voidPreOrder3（BTreeNode*BT）
{
StackS;
InitStack（S）;
BTreeNode*p=BT;
Push（S,p）;
while（!
EmptyStack（S））{
p=Pop（S）;
if（p!
=NULL）{
cout<data<<'';
Push（S,p->right）;
Push（S,p->left）;
}
}
cout<ClearStack（S）;
}
/*非递归中序遍历二叉树BT*/
voidInOrder2（BTreeNode*BT）
{
StackS;
InitStack（S）;
BTreeNode*p=BT;
while（p!
=NULL||!
EmptyStack（S））{
while（p!
=NULL）{
Push（S,p）;
p=p->left;
}
if（!
EmptyStack（S））{
p=Pop（S）;
cout<data<<'';
p=p->right;
}
}
cout<ClearStack（S）;
}
/*非递归层序遍历二叉树BT*/
voidLevelOrder2（BTreeNode*BT）{
QueueQ;
InitQueue（Q）;
if（BT!
=NULL）{
BTreeNode*p=BT;
EnQueue（Q,p）;
while（!
EmptyQueue（Q））{
p=OutQueue（Q）;
cout<data<<'';
if（p->left!
=NULL）
EnQueue（Q,p->left）;
if（p->right!
=NULL）
EnQueue（Q,p->right）;
}
}
cout<ClearQueue（Q）;
}
/*将二叉树中的所有结点的左右子树进行交换*/
voidChangeBTree（BTreeNode*&BT）
{
if（BT!
=NULL）{
BTreeNode*p;
p=BT->left;
BT->left=BT->right;
BT->right=p;
ChangeBTree（BT->left）;
ChangeBTree（BT->right）;
}
}
/*统计二叉树中的所有结点数并返回*/
intCountBTree（BTreeNode*BT）
{
if（BT==NULL）
return0;
elseif（BT->left==NULL&&BT->right==NULL）
return1;
else
returnCountBTree（BT->left）+CountBTree（BT->right）+1;
}
/*复制一棵二叉树，并返回复制得到的二叉树根结点指针*/
BTreeNode*CopyBTree（BTreeNode*BT）
{
if（BT==NULL）
returnNULL;
else{
BTreeNode*p=newBTreeNode;
p->data=BT->data;
p->left=CopyBTree（BT->left）;
p->right=CopyBTree（BT->right）;
returnp;
}
}
/*判断两棵二叉树是否相似*/
intSimilarTrees（BTreeNode*BT1,BTreeNode*BT2）
{
if（BT1==NULL&&BT2==NULL）
return1;
elseif（BT1==NULL||BT2==NULL）
return0;
else
returnSimilarTrees（BT1->left,BT2->left）&&SimilarTrees（BT1->right,BT2->right）;
}
/*摘树叶：
摘除一棵二叉树上的所有叶子结点后返回一棵新的二叉树*/
BTreeNode*RemoveLeaves（BTreeNode*BT）
{
if（BT==NULL）
returnNULL;
elseif（BT->left==NULL&&BT->right==NULL）{
free（BT）;
returnNULL;
}
else{
BT->left=RemoveLeaves（BT->left）;
BT->right=RemoveLeaves（BT->right）;
}
returnBT;
}
BTreeStack.h
structStack{
BTreeNode**stack;
inttop;
intMaxSize;
};
voidInitStack（Stack&S）
{
S.MaxSize=10;
S.stack=newBTreeNode*[S.MaxSize];
if（!
S.stack）{
cout<<"动态存储分配失败！
"<exit
（1）;
}
S.top=-1;
}
voidPush（Stack&S,BTreeNode*item）
{
if（S.top==S.MaxSize-1）{
intk=sizeof（BTreeNode）;
S.stack=（BTreeNode**）realloc（S.stack,2*S.MaxSize*k）;
S.MaxSize=2*S.MaxSize;
}
S.top++;
S.stack[S.top]=item;
}
BTreeNode*Pop（Stack&S）
{
if（S.top==-1）{
cerr<<"Stackisempty!
"<exit
（1）;
}
S.top--;
returnS.stack[S.top+1];
}
boolEmptyStack（Stack&S）
{
returnS.top==-1;
}
voidClearStack（Stack&S）
{
if（S.stack）{
delete[]S.stack;
S.stack=0;
}
S.top=-1;
S.MaxSize=0;
}
BTreeQueuee.h
structQueue{
BTreeNode**queue;
intfront,rear,len;
intMaxSize;
};
voidInitQueue（Queue&Q）
{
Q.MaxSize=10;
Q.queue=newBTreeNode*[Q.MaxSize];
Q.front=Q.rear=0;
}
voidEnQueue（Queue&Q,BTreeNode*item）
{
if（（Q.rear+1）%Q.MaxSize==Q.front）{
intk=sizeof（ElemType）;
Q.queue=（BTreeNode**）realloc（Q.queue,2*Q.MaxSize*k）;
if（Q.rear!
=Q.MaxSize-1）{
for（inti=0;i<=Q.rear;i++）
Q.queue[i+Q.MaxSize]=Q.queue[i];
Q.rear+=Q.MaxSize;
}
Q.MaxSize=2*Q.MaxSize;
}
Q.rear=（Q.rear+1）%Q.MaxSize;
Q.queue[Q.rear]=item;
}
BTreeNode*OutQueue（Queue&Q）
{
if（Q.front==Q.rear）{
cerr<<"队列已空，无法删除！
"<exit
（1）;
}
Q.front=（Q.front+1）%Q.MaxSize;
returnQ.queue[Q.front];
}
boolEmptyQueue（Queue&Q）
{
returnQ.front==Q.rear;
}
voidClearQueue（Queue&Q）
{
if（Q.queue!
=NULL）
delete[]Q.queue;
Q.front=Q.rear=0;
Q.queue=NULL;
Q.MaxSize=0;
}
升级会员 