数据结构二叉树遍历实验报告Word文件下载.docx
《数据结构二叉树遍历实验报告Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构二叉树遍历实验报告Word文件下载.docx（26页珍藏版）》请在冰豆网上搜索。
InitStack〔&
S〕
操作结果：
构造一个空栈
StackEmpty（S）初始条件：
栈S已存在。
假设S为空栈，那么返回OK，否那么返回ERROR。
Push（&
S,e）初始条件：
操作结果：
插入元素e为新的栈顶元素。
Pop（&
S,&
e）初始条件：
栈S已存在且非空。
删除S的栈顶元素，并用e返回其值。
GetTop（S,&
用e返回S的栈顶元素。
}
2.二叉树的抽象数据类型
ADTBinaryTree{
数据对象D：
D是具有一样特性的数据元素的集合。
数据关系R：
假设D=Φ，那么R=Φ，称BinaryTree为空二叉树；
假设D≠Φ，那么R={H}，H是如下二元关系；
〔1〕在D中存在惟一的称为根的数据元素root，它在关系H下无前驱；
〔2〕假设D-{root}≠Φ，那么存在D-{root}={D1,Dr}，且D1∩Dr=Φ；
〔3〕假设D1≠Φ，那么D1中存在惟一的元素x1，<
root,x1>
∈H，且存在D1上的关系H1⊆H；
假设Dr≠Φ，那么Dr中存在惟一的元素xr，<
root,xr>
∈H，且存在上的关系Hr⊆H；
H={<
<
H1,Hr}；
〔4〕（D1,{H1}）是一棵符合本定义的二叉树，称为根的左子树；
（Dr,{Hr}）是一棵符合本定义的二叉树，称为根的右子树。
CreateBiTree（&
T）初始条件：
给出二叉树T的定义。
按要求构造二叉树T。
PreOrderTraverse_re（T,print（））初始条件：
二叉树T存在，print是二叉树全部结点输出的应用函数。
先序递归遍历T，对每个结点调用函数print一次且仅一次。
一旦print（）失败，那么操作失败。
InOrderTraverse（T,print（））初始条件：
中序非递归遍历T，对每个结点调用函数print一次且仅一次。
一旦printf（）失败，那么操作失败。
InOrderTraverse_re（T,print（））
初始条件：
二叉树T在在，print是二叉树全部结点输出的应用函数。
中序递归遍历T，对每个结点调用函数print一次且仅一次。
一旦printf（）失败，那么操作失败。
PreOrderTraverse（T,print（））
初始条件：
先序非递归遍历T，对每个结点调用函数print一次且仅一次。
一旦print（）失败，那么操作失败。
Levelorder（T）
初始条件：
二叉树T在在。
分层遍历二叉树T，并输出。
InOrderThreading（Thrt,T）;
中序遍历二叉树，并将其中序线索化。
InOrderTraverse_Thr（T,print）;
中序非递归遍历二叉线索树T
InThreading（p）;
结点p在在。
结点p及子树线索化。
3.主程序的流程：
voidmain（）
{
初始化;
提示;
执行二叉数ADT函数;
4.本程序包含三个模块
1）主程序模块
voidmain（）{
初始化；
承受命令；
显示结果；
｝
2）链表模块。
递归调用时实现链表抽象数据类型。
3）栈模块。
非递归调用时实现栈的抽象数据类型。
详细设计
1.宏定义及全局变量
#defineTElemTypechar
#defineSElemTypeBiTree
#defineOK1
#defineOVERFLOW0
#defineERROR0
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
SqStackS;
BiThrTreepre;
BiThrTreei;
2.函数定义
intCreateBiTree（BiTree&
T）;
//创立二叉树
voidPreOrderTraverse_re（BiTreeT,void（*print）（TElemTypee））;
//先序递归遍历二叉树
voidInOrderTraverse（BiTreeT,int（*print）（TElemTypee））;
//中序非递归遍历二叉树
voidInOrderTraverse_re（BiTreeT,int（*print）（TElemTypee））;
//中序递归遍历二叉树
voidPreOrderTraverse（BiTreeT,int（*print）（TElemTypee））;
//先序非递归遍历二叉树
intprint（TElemTypee）;
//打印元素
voidInitStack（SqStack&
S）;
//栈的初始化
voidPop（SqStack&
S,SElemType&
e）;
voidPush（SqStack&
intStackEmpty（SqStackS）;
intGetTop（SqStackS,SElemType&
voidLevelorder（BiTreeT）;
voidInOrderThreading（BiThrTree&
Thrt,BiThrTreeT）;
intInOrderTraverse_Thr（BiThrTreeT,int（*print）（TElemTypee））;
voidInThreading（BiThrTreep）;
3.二叉树链表
数据构造：
typedefstructBiTNode{
TElemTypedata;
structBiTNode*lchild,*rchild;
PointerTagLTag,RTag;
}BiTNode,*BiTree,BiThrNode,*BiThrTree;
a）构造二叉树T
T）
charch;
scanf（"
%c"
&
ch）;
if（ch=='
'
）
T=NULL;
else
{
if（!
（T=（BiTNode*）malloc（sizeof（BiTNode））））
returnERROR;
T->
data=ch;
if（CreateBiTree（T->
lchild））T->
LTag=Link;
rchild））T->
RTag=Link;
}
returnOK;
b）先序递归遍历二叉数T，并输出全部结点值。
voidPreOrderTraverse_re（BiTreeT,int（*print）（TElemTypee））
if（T）
if（print（T->
data））
PreOrderTraverse_re（T->
lchild,print）;
PreOrderTraverse_re（T->
rchild,print）;
return;
c）中序非递归遍历二叉树T，并输出全部结点值
voidInOrderTraverse（BiTreeT,int（*print）（TElemTypee））
SqStackS;
S.base=NULL;
S.top=NULL;
SElemTypep=NULL;
InitStack（S）;
Push（S,T）;
while（!
StackEmpty（S））
while（GetTop（S,p）&
&
p）
Push（S,p->
lchild）;
Pop（S,p）;
{
Pop（S,p）;
print（p->
data）;
rchild）;
}
return;
d）中序递归遍历二叉树T，并输出全部结点值
voidInOrderTraverse_re（BiTreeT,int（*print）（TElemTypee））
{
if（T）
InOrderTraverse_re（T->
print（T->
}
e）中序遍历二叉树T，并将其中序线索化，Thrt指向头结点
voidInOrderThreading（BiThrTree&
Thrt,BiThrTreeT）
Thrt=（BiThrTree）malloc（sizeof（BiThrNode））;
Thrt->
//建头结点
RTag=Thread;
rchild=Thrt;
//右指针回指
if（!
lchild=Thrt;
Thrt->
lchild=T;
pre=Thrt;
InThreading（T）;
//中序遍历进展中序线索化
pre->
//最后一个结点线索化
rchild=pre;
i=Thrt;
}//InOrderThreading
f）结点p线索化
voidInThreading（BiThrTreep）{
if（p）{
InThreading（p->
//左子树线索化
if（!
p->
lchild）//建前驱线索
{p->
LTag=Thread;
p->
lchild=pre;
pre->
rchild）//建后继线索
{pre->
RTag=Thread;
pre->
rchild=p;
pre=p;
//保持pre指向p的前驱
//右子树线索化
}
}//InThreading
g）//中序遍历线索化二叉树
intInOrderTraverse_Thr（BiThrTreeT,int（*print）（TElemTypee））
BiThrTreep=NULL;
p=T->
lchild;
while（p!
=T）
while（p->
LTag==Link）
p=p->
print（p->
RTag==Thread&
rchild!
rchild;
p=p->
4.栈
typedefstruct{
SElemType*base;
SElemType*top;
intstacksize;
}SqStack;
a）创立一个空栈
S）
S.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;
S.top=S.base;
//初始为空
S.stacksize=STACK_INIT_SIZE;
b）栈顶插入元素
e）
if（S.top-S.base>
=S.stacksize）
S.base=（SElemType*）realloc（S.base,（STACK_INIT_SIZE+STACKINCREMENT）*sizeof（SElemType））;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
*S.top++=e;
c）栈顶删除元素
if（S.top==S.base）
return;
e=*--S.top;
d）判断栈是否为空栈
intStackEmpty（SqStackS）
returnOK;
returnERROR;
e）e返回S的栈顶元素
e=*（S.top-1）;
5.主函数
{intflag;
BiTreeT;
BiThrTreeThrt;
printf（"
******************************************************\n"
）;
**实验12二叉树的遍历**\n"
**1.实现二叉树的不同遍历算法和二叉树的中序线索化算法**\n"
**a）中序递归遍历算法；
**\n"
**b）先序递归遍历算法；
**c）中序遍历的非递归算法；
**d）先序或后序遍历非递归算法之一；
**e）建立中序线利用线索进展中序遍历和反中序遍历。
**2.实现二叉树的按层遍历算法。
**********************************************************\n"
\n选择操作：
\n\t1.先序与中序遍历算法\n\t2.中序线索的中序遍历和反中序遍历算法\n\t3.按层遍历算法\n请选择：
"
%d"
flag）;
switch（flag）
{case1:
printf（"
前序递归创立二叉树〔空格表示此结点为空〕:
\n"
getchar（）;
CreateBiTree（T）;
中序递归遍历输出:
InOrderTraverse_re（T,print）;
\n前序递归遍历输出：
PreOrderTraverse_re（T,print）;
\n中序非递归遍历输出：
InOrderTraverse（T,print）;
\n前序非递归遍历输出：
PreOrderTraverse（T,print）;
break;
case2:
\n中序遍历线索化二叉树:
InOrderThreading（Thrt,T）;
InOrderTraverse_Thr（Thrt,print）;
case3:
\n按层遍历输出：
Levelorder（T）;
default:
return;
}}
6.函数间调用关系
main
InOrderTraverse_re
CreateBitree
PreOrderTraverse_re
InOrderTraverse
PreOrderTraverse
InOrderThreading
InOrderTraverse_Thr
Threading
Stack操作
调试分析
1、二叉树的分层遍历，开场时想用队列来做，但考虑到比拟麻烦，因而改为数组模拟队列，简单易懂，课后可自行尝试用队列来做。
2．
在线索化二叉树时考虑到如果将两种存储构造分开将导致两个类型的指针不能互相传值，造成许多麻烦。
比拟两种存储构造发现，线索二叉树比二叉树多了两个标志域LTag,Rtag。
于是把两种存储构造合并为BiThrNode,并在建立二叉树时把LTag,Rtag均置为Link。
程序正常运行。
3.进入演示程序BiTree.cpp，完成编译，连接〔即按下CtrlF5〕进入演示界面，或直接翻开执行文件BiTree.exe，产生如下列图所示的界面：
1用户需根据用户提示信息操作，输入二叉树〔以空格表示空结点〕，输入完成后按回车键，屏幕上打印出对应于该二叉树的各种遍历结果。
如下列图：
六、测试结果
输入：
屏幕输出：
中序递归遍历输出：
a+b*c-d
前序递归遍历输出：
+a*b-cd
中序非递归遍历输出：
前序非递归遍历输出：
按层遍历输出：
中序遍历线索化二叉树：
七、附录
BiTree.cpp
BiTree.exe
#include<
stdio.h>
stdlib.h>
#defineQElemTypeBiTNode
typedefenumPointerTag{Link,Thread};
//Link==0,指针，Thread==1,线索
//二叉树
SElemType*base;
SElemType*top;
intstacksize;
//全局变量
/*函数声明*/
/*二叉树的创立递归创立*/
（T=（BiTNode*）mal
升级会员 