数据结构 二叉树遍历实验报告

数据结构之二叉树实验报告题目:二叉树的遍历和子树交换****:***班级：通信1202**:**学号：**********需求分析1.演示程序分别用多种遍历算法遍历二叉树并把数据输出。

2.输入字符序列，递归方式建立二叉树。

3.在演示过程序中，用户敲击键盘，输入数据，即可看到数据的输出。

4.实现链式存储的二叉树的多种遍历算法。

遍历算法包括：a)中序递归遍历算法、前序递归遍历算法【选】b)中序遍历非递归算法c)先序或后序遍历非递归算法d)建立中序线索，并进行中序遍历和反中序遍历5.实现二叉树的按层遍历算法6.设计一个测试用的二叉树并创建对应的内存二叉树，能够测试自己算法的边界(包括树节点数为0、1以及>1 的不同情形)。

7.测试数据：输入数据：-+a *b -c d -e f概要设计说明：本程序在递归调用中用到了链表，在非递归调用时用到了栈。

1.栈的抽象数据类型ADT Stack{数据对象：D={a i|a i∈char,i=1,2,3……..}数据关系：R={< a i-1,a i >| a i-1,a i∈D,i=2,3…..}基本操作：InitStack（&S）操作结果：构造一个空栈StackEmpty( S )初始条件：栈S已存在。

操作结果：若S为空栈，则返回OK，否则返回ERROR。

Push( &S, e )初始条件：栈S已存在。

操作结果：插入元素e为新的栈顶元素。

Pop( &S, &e )初始条件：栈S已存在且非空。

操作结果：删除S的栈顶元素，并用e返回其值。

GetTop( S, &e )初始条件：栈S已存在且非空。

操作结果：用e返回S的栈顶元素。

}2.二叉树的抽象数据类型ADT BinaryTree{数据对象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={<root,x1>,<root,xr>,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是二叉树全部结点输出的应用函数。

操作结果：中序非递归遍历T，对每个结点调用函数print一次且仅一次。

一旦printf()失败，则操作失败。

InOrderTraverse_re(T,print() )初始条件：二叉树T在在，print是二叉树全部结点输出的应用函数。

操作结果：中序递归遍历T，对每个结点调用函数print一次且仅一次。

一旦printf()失败，则操作失败。

PreOrderTraverse(T,print())初始条件：二叉树T存在，print是二叉树全部结点输出的应用函数。

操作结果：先序非递归遍历T，对每个结点调用函数print一次且仅一次。

一旦print()失败，则操作失败。

Levelorder(T)初始条件：二叉树T在在。

操作结果：分层遍历二叉树T，并输出。

InOrderThreading(Thrt,T);初始条件：二叉树T在在。

操作结果：中序遍历二叉树，并将其中序线索化。

InOrderTraverse_Thr( T, print);初始条件：二叉树T在在。

操作结果：中序非递归遍历二叉线索树TInThreading(p);初始条件：结点p在在。

操作结果：结点p及子树线索化。

3.主程序的流程：void main(){初始化;提示;执行二叉数ADT函数;}4.本程序包含三个模块1）主程序模块void main(){初始化；{接受命令；显示结果；｝｝2）链表模块。

递归调用时实现链表抽象数据类型。

3）栈模块。

非递归调用时实现栈的抽象数据类型。

详细设计1.宏定义及全局变量#define TElemType char#define SElemType BiTree#define OK 1#define OVERFLOW 0#define ERROR 0#define STACK_INIT_SIZE 100#define STACKINCREMENT 10SqStack S;BiThrTree pre;BiThrTree i;2.函数定义int CreateBiTree(BiTree &T); //创建二叉树void PreOrderTraverse_re(BiTree T,void (*print)(TElemType e)); //先序递归遍历二叉树void InOrderTraverse(BiTree T,int (*print)(TElemType e)); //中序非递归遍历二叉树void InOrderTraverse_re(BiTree T,int (*print)(TElemType e)) ; //中序递归遍历二叉树void PreOrderTraverse(BiTree T,int (*print)(TElemType e)); //先序非递归遍历二叉树int print(TElemType e); //打印元素void InitStack(SqStack &S); //栈的初始化void Pop(SqStack &S,SElemType &e);void Push(SqStack &S,SElemType &e);int StackEmpty(SqStack S);int GetTop(SqStack S,SElemType &e);void Levelorder(BiTree T) ;void InOrderThreading(BiThrTree &Thrt,BiThrTree T);int InOrderTraverse_Thr(BiThrTree T, int (*print)(TElemType e));void InThreading(BiThrTree p);3.二叉树链表数据结构：typedef struct BiTNode{TElemType data;struct BiTNode *lchild ,*rchild;PointerTag LTag , RTag;}BiTNode , *BiTree , BiThrNode , *BiThrTree;基本操作：a)构造二叉树Tint CreateBiTree(BiTree &T){char ch;scanf("%c",&ch);if(ch==' ')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))return ERROR;T->data=ch;if (CreateBiTree(T->lchild)) T->LTag=Link;if (CreateBiTree(T->rchild)) T->RTag=Link;}return OK;}b)先序递归遍历二叉数T，并输出全部结点值。

void PreOrderTraverse_re(BiTree T,int (*print)(TElemType e)){if(T){if(print(T->data))PreOrderTraverse_re(T->lchild,print);PreOrderTraverse_re(T->rchild,print);return ;}elsereturn ;}c)中序非递归遍历二叉树T，并输出全部结点值void InOrderTraverse(BiTree T,int (*print)(TElemType e)) {SqStack S;S.base=NULL;S.top=NULL;SElemType p=NULL;InitStack(S);Push(S,T);while(!StackEmpty(S)){while(GetTop(S,p)&&p)Push(S,p->lchild);Pop(S,p);if(!StackEmpty(S)){Pop(S,p);print(p->data);Push(S,p->rchild);}}return;}d)中序递归遍历二叉树T，并输出全部结点值void InOrderTraverse_re(BiTree T,int (*print)(TElemType e)) {if(T){InOrderTraverse_re(T->lchild,print);print(T->data);InOrderTraverse_re(T->rchild,print);}}e)中序遍历二叉树T，并将其中序线索化，Thrt指向头结点void InOrderThreading(BiThrTree &Thrt,BiThrTree T){Thrt=(BiThrTree)malloc(sizeof(BiThrNode));Thrt->LTag=Link;//建头结点Thrt->RTag=Thread;Thrt->rchild=Thrt;//右指针回指if(!T)Thrt->lchild=Thrt;else{Thrt->lchild=T;pre=Thrt;InThreading(T);//中序遍历进行中序线索化pre->rchild=Thrt;pre->RTag=Thread;//最后一个结点线索化Thrt->rchild=pre;}i=Thrt;}//InOrderThreadingf)结点p线索化void InThreading(BiThrTree p) {if (p) {InThreading(p->lchild); // 左子树线索化if (!p->lchild) // 建前驱线索{ p->LTag = Thread; p->lchild = pre; }if (!pre->rchild) // 建后继线索{ pre->RTag = Thread; pre->rchild = p; }pre = p; // 保持pre指向p的前驱InThreading(p->rchild); // 右子树线索化}} // InThreadingg)//中序遍历线索化二叉树int InOrderTraverse_Thr(BiThrTree T, int (*print)(TElemType e)) {BiThrTree p=NULL;p=T->lchild;while(p!=T){while(p->LTag==Link)p=p->lchild;if(!print(p->data))return ERROR;while(p->RTag==Thread && p->rchild!=T){p=p->rchild;print(p->data);}p=p->rchild;}return OK;}4.栈数据结构：typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;基本操作：a)创建一个空栈void InitStack(SqStack &S){S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));S.top=S.base; //初始为空S.stacksize=STACK_INIT_SIZE;return;}b)栈顶插入元素void Push(SqStack &S,SElemType &e){if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(STACK_INIT_SIZE+STACKINCRE MENT)*sizeof(SElemType));S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;}c)栈顶删除元素void Pop(SqStack &S,SElemType &e){if(S.top==S.base)return;e=*--S.top;return;}d)判断栈是否为空栈int StackEmpty(SqStack S){if(S.top==S.base)return OK;elsereturn ERROR;}e)e返回S的栈顶元素int GetTop(SqStack S,SElemType &e){if(S.top==S.base)return ERROR;e=*(S.top-1);return OK;}5.主函数void main(){int flag;BiTree T;BiThrTree Thrt;printf("******************************************************\n");printf("** 实验12 二叉树的遍历**\n");printf("** 1. 实现二叉树的不同遍历算法和二叉树的中序线索化算法**\n");printf("** a) 中序递归遍历算法；**\n");printf("** b) 先序递归遍历算法；**\n");printf("** c) 中序遍历的非递归算法；**\n");printf("** d) 先序或后序遍历非递归算法之一；**\n");printf("** e) 建立中序线利用线索进行中序遍历和反中序遍历。