实验三二叉树的遍历Word文档格式.docx

实验三二叉树的遍历Word文档格式.docx

《实验三二叉树的遍历Word文档格式.docx》由会员分享，可在线阅读，更多相关《实验三二叉树的遍历Word文档格式.docx（21页珍藏版）》请在冰豆网上搜索。

}BinTree;

voidpreorder（BinTree*t）;

//声明先根遍历函数

voidinorder（BinTree*t）;

//声明中根遍历函数

voidpostorder（BinTree*t）;

//声明后根遍历函数

intleafs（BinTree*b）;

//声明求叶子数函数

inttreedeep（BinTree*p）;

//声明求树的深度函数

BinTree*swap（BinTree*p）;

//声明交换二叉树的所有结点的左右子树的函数

//将字符串中的第i个字符开始的m个字符作为数据生成对应的二叉树

BinTree*cre_tree（char*str,inti,intm）

{

BinTree*p;

if（i>

=m）//无效结点

returnNULL;

p=（BinTree*）malloc（sizeof（BinTree））;

//生成新结点

p->

data=str[i];

lchild=cre_tree（str,2*i+1,m）;

//创建新结点的左子树

rchild=cre_tree（str,2*i+2,m）;

//创建新结点的右子树

returnp;

}

voidmain（）

inti,n;

charstr[max];

BinTree*root;

//根结点

printf（"

请输入二叉树的结点数:

"

）;

scanf（"

%d"

&

n）;

getchar（）;

//输入数字

请输入长度为%d的字符串:

n）;

for（i=0;

i<

n;

i++）

scanf（"

%c"

str[i]）;

\n"

root=cre_tree（str,0,n）;

二叉树已成功创建!

结点序列为：

for（i=0;

printf（"

%c"

str[i]）;

printf（"

//先根遍历

\n先根遍历结果:

preorder（root）;

//中根遍历

\n中根遍历结果:

inorder（root）;

//后根遍历

\n后根遍历结果:

postorder（root）;

\n叶子数为：

%d\n"

leafs（root））;

\n树的深度为：

treedeep（root））;

\n交换左右子树后先序遍历序列为：

preorder（swap（root））;

\n\n"

voidpreorder（BinTree*t）

if（t!

=NULL）

{

t->

data）;

if（t->

lchild）

{

printf（"

->

preorder（t->

lchild）;

}

rchild）

rchild）;

}

voidinorder（BinTree*t）

inorder（t->

voidpostorder（BinTree*t）

postorder（t->

intleafs（BinTree*b）//求叶子数

intnum1,num2;

if（b==NULL）return（0）;

elseif（b->

lchild==NULL&

&

b->

rchild==NULL）return

（1）;

else

num1=leafs（b->

num2=leafs（b->

return（num1+num2）;

inttreedeep（BinTree*p）//求树的深度

intldeep,rdeep,deep;

if（p==NULL）deep=0;

ldeep=treedeep（p->

rdeep=treedeep（p->

deep=（ldeep>

rdeep?

ldeep:

rdeep）+1;

returndeep;

BinTree*swap（BinTree*p）//交换二叉树的所有结点的左右子树

BinTree*stack[max];

intk=0;

stack[k]=NULL;

if（p!

stack[++k]=p->

lchild;

p->

lchild=p->

rchild;

rchild=stack[k];

lchild=swap（p->

rchild=swap（p->

//按完全二叉树思想将输入的字符串生成二叉树

#include<

typedefstructBnode

{chardata;

structBnode*lchild,*rchild;

}Btree;

voidpreorder（Btree*t）

{if（t）

{printf（"

if（t->

{printf（"

preorder（t->

voidinorder（Btree*t）

{inorder（t->

inorder（t->

voidpostorder（Btree*t）

{postorder（t->

postorder（t->

intleafs（Btree*b）

{intnum1,num2;

if（b==NULL）return（0）;

lchild==NULL&

b->

rchild==NULL）return

（1）;

inttreedeep（Btree*p）

{intldeep,rdeep,deep;

{ldeep=treedeep（p->

rdeep=treedeep（p->

deep=（ldeep>

Btree*swap（Btree*p）

{Btree*stack[max];

{stack[++k]=p->

Btree*cretree（char*str,inti,intm）

{Btreep;

=m）

returnNULL;

p=（Btree*）malloc（sizeof（Btree））;

lchild=cretree（str,2*i+1,m）;

rchild=cretree（str,2*i+2,m）;

{inti,n;

Btree*root;

Btree*cretree（）

{Btree*p;

charch;

ch=getchar（）;

if（ch=='

#'

）returnNULL;

data=ch;

lchild=cretree（）;

rchild=cretree（）;

;

root=cretree（）;

}改过#definemax30

if（（ch=getchar（））=='

#include"

stdio.h"

string.h"

iostream>

cstdlib>

#defineMax20//结点的最大个数

usingnamespacestd;

typedefstructnode{

chardata;

structnode*lchild,*rchild;

}BinTNode;

//自定义二叉树的结点类型

typedefBinTNode*BinTree;

//定义二叉树的指针

intNodeNum,leaf;

//NodeNum为结点数，leaf为叶子数

BinTreeCreatBinTree（void）

{//==========基于先序遍历算法创建二叉树==============

//=====要求输入先序序列，其中加入虚结点"

#"

以示空指针的位置==========

BinTreeT;

）

return（NULL）;

//读入#，返回空指针

else{

T=（BinTNode*）malloc（sizeof（BinTNode））;

//生成结点

T->

T->

lchild=CreatBinTree（）;

//构造左子树

rchild=CreatBinTree（）;

//构造右子树

return（T）;

voidPreorder（BinTreebt）

{//========NLR先序遍历=============

if（bt!

=NULL）{

bt->

//访问结点

Preorder（bt->

//先序遍历左子树

//先序遍历右子树

voidInorder（BinTreebt）

{//========LNR中序遍历===============

Inorder（bt->

voidPostorder（BinTreebt）

Postorder（bt->

intTreeDepth（BinTreebt）

inthl,hr,max;

if（bt）

hl=TreeDepth（bt->