二叉树的遍历，深度求解以及竖向打印详析

二叉树是每个节点最多有两个子树的有序树。二叉树常被用于实现二叉查找树和二叉堆。值得注意的是，二叉树不是树的特殊情形。在图论中，二叉树是一个连通的无环图，并且每一个顶点的度不大于2。有根二叉树还要满足根结点的度不大于2。有了根结点后，每个顶点定义了唯一的根结点，和最多2个子结点。然而，没有足够的信息来区分左结点和右结点。二叉树详细请看本文：二叉树

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。

代码如下：

#include<iostream>
#include<cstdlib>
using namespace std;
typedef char ElemType;
typedef struct Node
{
ElemType data;
struct Node* LChild;
struct Node* RChild;
}BiTNode,*BiTree;
int LeafCount;
int Depth;

void Visit(ElemType T)//用于遍历的输出
{
cout<<T;
}

//1.建立二叉树
void CreateBiTree(BiTree *bt)
{
char ch;
ch = getchar();
if(ch=='.') *bt=NULL;
else
{
*bt=(BiTree)malloc(sizeof(BiTNode)); //生成一个新结点
(*bt)->data=ch;
CreateBiTree(&((*bt)->LChild)); //生成左子树
CreateBiTree(&((*bt)->RChild)); //生成右子树
}
}

//2.二叉树遍历

void  PreOrder(BiTree root)
/*先序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/
{
if (root!=NULL)
{
Visit(root ->data);  /*访问根结点*/
PreOrder(root ->LChild);  /*先序遍历左子树*/
PreOrder(root ->RChild);  /*先序遍历右子树*/
}
else
cout<<".";
}
void  InOrder(BiTree root)
/*中序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/
{
if (root!=NULL)
{
InOrder(root ->LChild);   /*中序遍历左子树*/
Visit(root ->data);        /*访问根结点*/
InOrder(root ->RChild);   /*中序遍历右子树*/
}
else
cout<<".";
}
void  PostOrder(BiTree root)
/* 后序遍历二叉树，root为指向二叉树(或某一子树)根结点的指针*/
{
if(root!=NULL)
{
PostOrder(root ->LChild); /*后序遍历左子树*/
PostOrder(root ->RChild); /*后序遍历右子树*/
Visit(root ->data);       /*访问根结点*/
}
else
cout<<".";
}

//3.输出二叉树上的“叶子”节点(三种方法，只写了先序，中后请参考前面的2.二叉树遍历)

void  leafPreOrder(BiTree root)
/*先序遍历二叉树, root为指向二叉树根结点的指针*/
{
if (root!=NULL)
{
if (root ->LChild==NULL && root ->RChild==NULL)
Visit(root->data);  /*输出叶子结点*/
PreOrder(root ->LChild);  /*先序遍历左子树*/
PreOrder(root ->RChild);  /*先序遍历右子树*/
}
}

//4.统计叶子节点数目(两个方法)

/* LeafCount保存叶子结点的数目的全局变量,调用之前初始化值为0 */
void leaf_a(BiTree root)//统计叶子节点数目法1
{
if(root!=NULL)
{
leaf_a(root->LChild);
leaf_a(root->RChild);
if (root ->LChild==NULL && root ->RChild==NULL)
LeafCount++;
}
}

int leaf_b(BiTree root)//统计叶子节点数目法2
{
int LeafCount2;
if(root==NULL)
LeafCount2 =0;
else
if((root->LChild==NULL)&&(root->RChild==NULL))
LeafCount2 =1;
else
LeafCount2 =leaf_b(root->LChild)+leaf_b(root->RChild);
/* 叶子数为左右子树的叶子数目之和 */
return LeafCount2;
}

//6.后序遍历求二叉树的高度递归算法

int PostTreeDepth(BiTree bt)
{
int hl,hr,max;
if(bt!=NULL)
{
hl=PostTreeDepth(bt->LChild);  /* 求左子树的深度 */
hr=PostTreeDepth(bt->RChild);  /* 求右子树的深度 */
max=hl>hr?hl:hr;              /* 得到左、右子树深度较大者*/
return(max+1);               /* 返回树的深度 */
}
else return(0);             /* 如果是空树，则返回0 */
}

//6.前序遍历求二叉树的高度递归算法

void PreTreeDepth(BiTree bt, int h)
/* 前序遍历求二叉树bt高度的递归算法，h为bt指向结点所在层次，初值为1*/
/*depth为当前求得的最大层次，为全局变量，调用前初值为0 */
{
if(bt!=NULL)
{
if(h>Depth)
Depth = h;     /*如果该结点层次值大于depth，更新depth的值*/
PreTreeDepth(bt->LChild, h+1);  /* 遍历左子树 */
PreTreeDepth(bt->RChild, h+1);  /* 遍历右子树 */
}
}

//7.“竖向”打印二叉树

void PrintTree(BiTree bt,int nLayer)  /* 按竖向树状打印的二叉树 */
{
if(bt == NULL) return;
PrintTree(bt->RChild,nLayer+1);
for(int i=0;i<nLayer;i++)
printf("  ");
printf("%c\n",bt->data);
PrintTree(bt->LChild,nLayer+1);
}

int main()
{
LeafCount =0;Depth=0;
BiTree T=NULL;
cout<<"请以先序输出的形式输入二叉树构造二叉链表："<<endl;
CreateBiTree(&T);
cout<<"先序遍历二叉树为："<<endl;
PreOrder(T);
cout<<endl<<"中序遍历二叉树为："<<endl;
InOrder(T);
cout<<endl<<"后序遍历二叉树为："<<endl;
PostOrder(T);
cout<<endl<<"先序输出二叉树叶子节点为："<<endl;
leafPreOrder(T);
cout<<endl<<"叶子节点数目为:"<<endl;
leaf_a(T);
cout<<endl<<"方法一显示共有"<<LeafCount<<"个叶子节点"<<endl;

cout<<endl<<"方法二显示共有"<<leaf_b(T)<<"个叶子节点"<<endl;

cout<<endl<<"后序遍历求二叉树的高度为"<<PostTreeDepth(T)<<endl;
PreTreeDepth(T,1);
cout<<endl<<"前序遍历求二叉树的高度为"<<Depth<<endl;

cout<<endl<<"竖状打印二叉树为："<<endl;
PrintTree(T,1);
return 0;
}

附带二叉树遍历的非递归算法：

/* 中后非递归遍历二叉树，作为遍历方法的参考*/

//8.中序遍历二叉树非递归算法(三个)

/*算法a*/
void inorder(BiTree root);
{
int top=0; p=bt;
L1: if (p!=NULL)       /* 遍历左子树 */
{
top=top+2;
if(top>m) return;       /*栈满溢出处理*/
s[top-1]=p;            /* 本层参数进栈 */
s[top]=L2;             /* 返回地址进栈 */
p=p->LChild;           /* 给下层参数赋值 */
goto L1;               /* 转向开始 */
L2:  Visit(p->data);     /* 访问根 */
top=top+2;
if(top>m) return;       /*栈满溢出处理*/;
s[top-1]=p;            /* 遍历右子树 */
s[top]=L3;
p=p->RChild;
goto L1;
}
L3: if(top!=0)
{
addr=s[top];
p=s[top-1];            /* 取出返回地址 */
top=top-2;             /* 退出本层参数 */
goto addr;
}
}

/*算法b*/
void inorder(BiTree root)   /* 中序遍历二叉树，root为二叉树的根结点 */
{
int top=0;
BiTree p;
BiTree s[Stack_Size];
int m;
m = Stack_Size-1;
p = root;
do
{
while(p!=NULL)
{
if (top>m) return;
top=top+1;
s[top]=p;
p=p->LChild;
};  /* 遍历左子树 */
if(top!=0)
{
p=s[top];
top=top-1;
Visit(p->data);  /* 访问根结点 */
p=p->RChild;  /* 遍历右子树 */
}
}
while(p!=NULL || top!=0);
}

/*算法c*/
void  InOrder(BiTree root) /* 中序遍历二叉树的非递归算法 */
{
SeqStack S;
BiTree p;
InitStack (&S);
p=root;
while(p!=NULL || !IsEmpty(&S))
{
if (p!=NULL)  /* 根指针进栈，遍历左子树 */
{
Push(&S,p);
p=p->LChild;
}
else
{  /*根指针退栈，访问根结点，遍历右子树*/
Pop(&S,&p);
Visit(p->data);
p=p->RChild;
}
}
}

//9.后序遍历二叉树的非递归算法

void PostOrder(BiTree root)
{
BiTNode *p,*q;
BiTNode **s;
int top=0;
q=NULL;
p=root;
s=(BiTNode**)malloc(sizeof(BiTNode*)*NUM);
/* NUM为预定义的常数 */
while(p!=NULL || top!=0)
{
while(p!=NULL)
{
top++;
s[top]=p;
p=p->LChild;
}  /*遍历左子树*/
if(top>0)
{
p=s[top];
if((p->RChild==NULL) ||(p->RChild==q))	/* 无右孩子，或右孩子已遍历过 */
{
visit(p->data);        /* 访问根结点*/
q=p;            	/* 保存到q，为下一次已处理结点前驱 */
top--;
p=NULL;
}
else
p=p->RChild;
}
}
free(s);
}