二叉树的遍历方法,二叉树的三种遍历，先，中，后遍历

二叉树的遍历方法,二叉树的三种遍历，先，中，后遍历详细介绍

本文目录一览： 怎么遍历二叉树？

1）先序遍历，按照根左右的顺序沿一定路径经过路径上所有的结点。在二叉树中，先根后左再右。
2）中序遍历，首先遍历左子树，然后访问根结点，最后遍历右子树。
3）后序遍历，可记做左右根。在二叉树中，先左后右再根，即首先遍历左子树，然后遍历右子树，最后访问根结点。
4）这棵二叉树的根节点是A。
5）画出二叉树：

二叉树三种遍历技巧

在二叉树的前序遍历，中序遍历，后序遍历这三种遍历方式中，有两个相同的特点就是左子树总是在右子树的之前遍历。还有他们的遍历都可以用递归的方式来描述。
前序遍历的方式是：首先访问根节点，然后访问左子树，最后访问右子树。
中序遍历的方式是：首先访问左子树，接着访问根结点，最后访问右子树。
后序遍历的方式是：首先访问左子树，接着访问右子树，最后访问根结点。

如何实现二叉树的遍历？

在vc6.0环境下实现，代码如下，这些算法方面的建议还是找本书看看好：
#include

#include

typedef struct Node

{

char data;

struct Node *lchild;

struct Node *rchild;

}BiTreeNode;

BiTreeNode *CreatBiTree(BiTreeNode *t,char *s)//二叉树的创建

{

BiTreeNode *p[1024];

BiTreeNode *q=NULL;

int top=0;

int i=0,j,len=0;

char ch;

ch=s[i];

while(ch!='\0')

{

switch(ch)

{

case '(':

top++;

p[top]=q;

j=1;

break;

case ')':

top--;

break;

case ',':

j=2;

break;

default:

q=(BiTreeNode *)malloc(sizeof(BiTreeNode));

q->data=ch;

q->lchild=q->rchild=NULL;

if(t==NULL)

t=q;

else

{

switch(j)

{

case 1:

p[top]->lchild=q;

break;

case 2:

p[top]->rchild=q;

break;

}

}

}

i++;

ch=s[i];

}

return t;

}

void PreOrder(BiTreeNode *t)//先序遍历

{

if(t!=NULL)

{

printf("%c ",t->data);

PreOrder(t->lchild);

PreOrder(t->rchild);

}

}

void InOrder(BiTreeNode *t)//中序遍历

{

if(t!=NULL)

{

PreOrder(t->lchild);

printf("%c ",t->data);

PreOrder(t->rchild);

}

}

void PostOrder(BiTreeNode *t)//后序遍历

{

if(t!=NULL)

{

PreOrder(t->lchild);

PreOrder(t->rchild);

printf("%c ",t->data);

}

}

int BiTreeDepth(BiTreeNode *t)

{

int dep=0,depl,depr;

if(!t)

dep=0;

else

{

depl=BiTreeDepth(t->lchild);

depr=BiTreeDepth(t->rchild);

dep=1+(depl>depr?depl:depr);

}

return dep;

}

void main()

{

BiTreeNode *t=NULL;

char *s="a(b(d,e),c)";

t=CreatBiTree(t,s);

printf("先序遍历：");

PreOrder(t);

printf("\n");

printf("中序遍历：");

InOrder(t);

printf("\n");

printf("后序遍历：");

PostOrder(t);

printf("\n");

printf("二叉树深度为%d\n",BiTreeDepth(t));

}

二叉树的遍历分好几种

1:先根遍历

2:中根遍历

3:后根遍历

主要就是用递规的思想.

要代码的话追问吧

二叉树的遍历

在遍历二叉树的过程中，一般先遍历左子树，再遍历右子树。

（1）前序遍历

先访问根结点，然后遍历左子树，最后遍历右子树；并且在遍历左、右子树时，仍需先访问根结点，然后遍历左子树，最后遍历右子树。

（2）中序遍历

先遍历左子树、然后访问根结点，最后遍历右子树；并且，在遍历左、右子树时，仍然先遍历左子树，然后访问根结点，最后遍历右子树。

（3）后序遍历

先遍历左子树、然后遍历右子树，最后访问根结点；并且，在遍历左、右子树时，仍然先遍历左子树，然后遍历右子树，最后访问根结点。

二叉树的先序,中序,后序遍历是？

前序遍历就是先遍历根节点，然后遍历左节点，最后是右节点；
中序遍历就是先遍历左节点，然后遍历中间的根节点，最后是右节点；
后序遍历就是先遍历左节点，然后遍历是右节点，最后是中间的根节点。
二叉树的这三种遍历方法，是按照每颗子树的根节点顺序遍历的。
扩展资料：
例子：已知二叉树的后序遍历序列是dabec，中序遍历序列是debac，它的前序遍历序列是（cedba）
(1)中序遍历：debac
后序遍历：dabec
后序遍历序列的最后一个结点是根结点，所以可知c为根结点。
中序遍历序列的根结点在中间，其左边是左子树，右边是右子树。所以从中序遍历序列中可看出，根结点c只有左子树，没有右子树。
(2)中序遍历：deba
后序遍历：dabe
后序遍历序列的最后一个结点是根结点，所以可知e为c的左子树的根结点。
中序遍历序列的根结点在中间，其左边是左子树，右边是右子树。所以从中序遍历序列中可看出，根结点e的左子结点是d，右子树是ba。
(3)中序遍历：ba
后序遍历：ab
由后序遍历序列可知b为e的右子树的根结点。由中序遍历序列中可看出，a为根结点b的右子结点。

二叉树的三种遍历，先，中，后遍历

二叉树的遍历分为以下三种：
先序遍历：遍历顺序规则为【根左右】
中序遍历：遍历顺序规则为【左根右】
后序遍历：遍历顺序规则为【左右根】
什么是【根左右】？就是先遍历根，再遍历左孩子，最后遍历右孩子；
举个例子，看下图（图从网上找的）：
先序遍历：ABCDEFGHK
中序遍历：BDCAEHGKF
后序遍历：DCBHKGFEA
以中序遍历为例：
中序遍历的规则是【左根右】，我们从root节点A看起；
此时A是根节点，遍历A的左子树；
A的左子树存在，找到B，此时B看做根节点，遍历B的左子树；
B的左子树不存在，返回B，根据【左根右】的遍历规则，记录B，遍历B的右子树；
B的右子树存在，找到C，此时C看做根节点，遍历C的左子树；
C的左子树存在，找到D，由于D是叶子节点，无左子树，记录D，无右子树，返回C，根据【左根右】的遍历规则，记录C，遍历C的右子树；
C的右子树不存在，返回B，B的右子树遍历完，返回A；
至此，A的左子树遍历完毕，根据【左根右】的遍历规则，记录A，遍历A的右子树；
A的右子树存在，找到E，此时E看做根节点，遍历E的左子树；
E的左子树不存在，返回E，根据【左根右】的遍历规则，记录E，遍历E的右子树；
E的右子树存在，找到F，此时F看做根节点，遍历F的左子树；
F的左子树存在，找到G，此时G看做根节点，遍历G的左子树；
G的左子树存在，找到H，由于H是叶子节点，无左子树，记录H，无右子树，返回G，根据【左根右】的遍历规则，记录G，遍历G的右子树；
G的右子树存在，找到K，由于K是叶子节点，无左子树，记录K，无右子树，返回G，根据【左根右】的遍历规则，记录F，遍历F的右子树；
F的右子树不存在，返回F，E的右子树遍历完毕，返回A；
至此，A的右子树也遍历完毕；
最终我们得到上图的中序遍历为BDCAEHGKF，无非是按照遍历规则来的；
根据“中序遍历”的分析，相信先序遍历和后序遍历也可以轻松写出~
前序遍历:ABDECFG
中序遍历:DBEAFCG
后序遍历:DEBFGCA
前序遍历:1 2 4 3 5 7 6
中序遍历:2 4 1 5 7 3 6
后序遍历:4 2 7 5 6 3 1
做类似的题目，你可以先由两个遍历画出二叉树。通过形象的二叉树来写出另一个遍历，写的方法如上（递归）。画出二叉树的方法如下：
已知一棵二叉树的前序序列和中序序列，构造该二叉树的过程如下：
1. 根据前序序列的第一个元素建立根结点；
2. 在中序序列中找到该元素，确定根结点的左右子树的中序序列；
3. 在前序序列中确定左右子树的前序序列；
4. 由左子树的前序序列和中序序列建立左子树；
5. 由右子树的前序序列和中序序列建立右子树。
已知一棵二叉树的后序序列和中序序列，构造该二叉树的过程如下：
1. 根据后序序列的最后一个元素建立根结点；
2. 在中序序列中找到该元素，确定根结点的左右子树的中序序列；
3. 在后序序列中确定左右子树的后序序列；
4. 由左子树的后序序列和中序序列建立左子树；
5. 由右子树的后序序列和中序序列建立右子树。
先序就是先遍历根，再遍历左子树，再遍历右子树。例如上图的先序遍历是：ABCDEFGHK
中序就是先遍历左子树，再遍历根，再右子树。例如上图的中序遍历是：BDCAEHGKF
后序就是先遍历左子树，再右子树，再根。例如上图的后序遍历是：DCBHKGFEA

遍历二叉树

同学，你们老师和我们老师留的作业是一模一样的阿，我有现成的做好了的程序，调试成功。这个程序的难点就在于这种很别扭的输入形式，所以我为它设计了一个结构体形式存放输入内容，再将它转化成了线性结构。
#include

#include

struct inform /*建立输入信息结构体inform*/

{ char data;

int l;

int r;

int signl; /*作为标记的signl,signr*/

int signr;

};

struct leafnode /*建立叶子节点结构体*/

{

char leaf;

leafnode* lchild;

leafnode* rchild;

};

void print(inform* ps, int n);

void judge ( inform* ps );

leafnode* creatree(); /*声明二叉树的建立函数*/

void preorder (leafnode* T); /*声明先序遍历函数*/

void inorder (leafnode* T); /*声明中序遍历函数*/

void postorder (leafnode* T); /*声明后序遍历函数*/

char a[100];

int k=1;

int s=0;

inform *p;

void main()

{

/*-------------------------------按格式输入信息-----------------------------------*/

int n;

cout<<"请输入二叉树内容：第一行为节点总数n ，后面的n行是节点的具体形式："<
<endl;
cout<<"n= ";

cin>>n;

p=(inform* )malloc( n*sizeof(inform) ); /*开辟的一个叶子结构体型的指针数组*/

inform *p1; p1=p;

for(int i=0; i
<n; i++)

{

cin>>(p+i)->data>>(p+i)->l>>(p+i)->r;

if((p+i)->l != -1) (p+i)->signl=1; /*用signl signr 的0，1标示输入的信息中是否有左或右孩子*/

else (p+i)->signl= 0;

if((p+i)->r !=-1) (p+i)->signr=1;

else (p+i)->signr= 0;

}

/*--------------------------------------------------------------------------------------------*/

a[0]= p->data;

judge ( p1 ); /*用递归算法将输入数据信息转为线性字符串*/

cout<
<endl<<"输出转换的线性字符串： "<<endl;
cout<
<a<<endl<<endl;
/*------------------------------------------遍历-----------------------------------*/

leafnode* T;

T= creatree();

/*先续遍历二叉树*/

cout<<"先序遍历二叉树： "<
<endl;
preorder( T );

cout<
<endl<<"中序遍历二叉树： "<<endl;
inorder ( T );

cout<
<endl<<"后序遍历二叉树： "<<endl;
postorder( T );

cout<
<endl<<endl;
}

/*------------------------------------------函数定义-------------------------------*/

void judge( inform* ps ) /*用函数的递归来将输入的信息转化为线性的数组*/

{

inform* b;

if (ps->signl==0)

{

a[k]='@';

k++;

}

else

{

b = p+(ps->l);

a[k] = b->data;

k++;

judge(b);

}

if ((ps->signr) == 0)

{

a[k]='@';

k++;

}

else

{

b = p+(ps->r );

a[k] = b->data;

k++;

judge(b);

}

}

leafnode* creatree() /*建立二叉树函数*/

{

char ch;

leafnode *t;

ch= a[s];

s++;

if(ch=='@')

{

t=NULL;

}

else

{

t=(leafnode* )malloc(sizeof(leafnode));

t->leaf=ch;

t->lchild=creatree();

t->rchild=creatree();

}

return t;

}

/*先序遍历的递归函数*/

void preorder (leafnode* T)

{

if(T)

{

cout<

leaf;

preorder(T->lchild);

preorder(T->rchild);

}

}

/*中序遍历的递归函数*/

void inorder (leafnode* T)

{

if(T)

{

inorder(T->lchild);

cout<

leaf;

inorder(T->rchild);

}

}

/*后序遍历的递归函数*/

void postorder (leafnode* T)

{

if(T)

{

postorder(T->lchild);

postorder(T->rchild);

cout<

leaf;

}

}

按你的描述，应该采用顺序表来存储数据。

楼上用的是动态链表来存储，显然不合要求。

但是按你描述的结构操作不方便，可不可以在后面的n行中再加一个整数表示其父结点,当父节点值为-1时表示根结点？

这样数据结构为：

typedef struct BTreeNode{

char ch;

int parent;

int lchild;

int rchild;

}BTreeNode;

struct BTree{

BTreeNode *body;/*用于存储二叉树的所有节点*/

int root;/*根节点序号*/

int count;/*节点数*/

}

待续。。。。

源代码：

typedef struct BTreeNode{

char ch;

int parent;

int lchild;

int rchild;

}BTreeNode;

struct BTree{

BTreeNode *body;/*用于存储二叉树的所有节点*/

int root;/*根节点序号*/

int count;/*节点数*/

}

/*创建二叉树*/

BTree createBTree(){

int i,n;

BTree bTree;

printf("请输入节点数：");

scanf("%d",&n);

bTree.body = (BTreeNode) malloc(sizeof(BTreeNode)*n);

bTree.root = -1;

bTree.count = n;

do{

for( i=0; i
<n; i++ ){
printf("请输入：节点字符 父节点序号 左节点序号 右节点序号：\n");

scanf("%c %d %d %d",bTree.body[i]->ch,

bTree.body[i]->parent,

bTree.body[i]->lchild,

bTree.body[i]->rchild);

if( bTree.body[i]->parent == -1 ){

bTree.root = i;

break;

}

}

}while( bTree.root == -1 );

return bTree;

}

/*以输出遍历序列为例的遍历方法*/

void travel(BTree *bTree, int i, int pattern ){

/**

* pattern=0表示先序遍历，1表示中序，2表示后序;

*

*/

if( pattern == 0 )

printf("%c",bTree->body[i]->ch);

if( bTree->body[i]->lchild != -1 ){

travel(bTree, bTree->body[i]->lchild, pattern);

if( pattern == 1 )

printf("%c",bTree->body[i]->ch);

}

if( bTree->body[i]->rchild != -1 ){

travel(bTree, bTree->body[i]->rchild, pattern);

if( pattern == 2 )

printf("%c",bTree->body[i]->ch);

}

}

void travelBTree(BTree *bTree , int pattern ){

if( pattern == 0) printf("先序遍历：");

if( pattern == 1) printf("中序遍历：");

if( pattern == 2) printf("后序遍历：");

travel( bTree, bTree->root, pattern );

printf("\n");

}

/*通用遍历方法*/

void travel2(BTree *bTree, int i, int pattern, void (*func)(BTree *bTree,int i) ){

/**

* pattern=0表示先序遍历，1表示中序，2表示后序;

* void (*func)(BTree *bTree,int i)中func为函数指针，用于指定遍历进行的操作。

*/

if( pattern == 0 )

(*func)( bTree, i );

if( bTree->body[i]->lchild != -1 ){

travel2(bTree, bTree->body[i]->lchild, pattern, func);

if( pattern == 1 )

(*func)( bTree, i)

}

if( bTree->body[i]->rchild != -1 ){

travel2(bTree, bTree->body[i]->rchild, pattern, func);

if( pattern == 2 )

(*func)( bTree, i);

}

}

/*测试,数据自定*/

void print( BTree *bTree, int i ){

printf("%c",bTree->body[i]->ch );

}

void main(){

BTree bTree;

void (*func)( BTree *bTree, int i );

bTree = createBTree();

travelBTree( &bTree, 0 );

travelBTree( &bTree, 1 );

travelBTree( &bTree, 2 );

/*通用遍历算法测试*/

func = print;

travel2( &bTree, bTree.root, 0, func);

printf("\n");

travel2( &bTree, bTree.root, 1, func);

printf("\n");

travel2( &bTree, bTree.root, 2, func);

printf("\n");

}

运行时可能会报错，因为我没有调试，你自己调试一下。

我来了

O(∩_∩)O~

遍历方案：

1．遍历方案

从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作：

（1）访问结点本身(N)，

（2）遍历该结点的左子树(L)，

（3）遍历该结点的右子树(R)。

以上三种操作有六种执行次序：

NLR、LNR、LRN、NRL、RNL、RLN。

注意：

前三种次序与后三种次序对称，故只讨论先左后右的前三种次序。

2．三种遍历的命名

根据访问结点操作发生位置命名：

① NLR：前序遍历(PreorderTraversal亦称(先序遍历))

——访问结点的操作发生在遍历其左右子树之前。

② LNR：中序遍历(InorderTraversal)

——访问结点的操作发生在遍历其左右子树之中(间)。

③ LRN：后序遍历(PostorderTraversal)

——访问结点的操作发生在遍历其左右子树之后。

注意：

由于被访问的结点必是某子树的根，所以N(Node)、L(Left subtree)和R(Right subtree)又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

遍历算法

1．中序遍历的递归算法定义：

若二叉树非空，则依次执行如下操作：

(1)遍历左子树；

(2)访问根结点；

(3)遍历右子树。

2．先序遍历的递归算法定义：

若二叉树非空，则依次执行如下操作：

(1) 访问根结点；

(2) 遍历左子树；

(3) 遍历右子树。

3．后序遍历得递归算法定义：

若二叉树非空，则依次执行如下操作：

(1)遍历左子树；

(2)遍历右子树；

(3)访问根结点。

4．中序遍历的算法实现

用二叉链表做为存储结构，中序遍历算法可描述为：

void InOrder(BinTree T)

{ //算法里①~⑥是为了说明执行过程加入的标号

① if(T) { // 如果二叉树非空

② InOrder(T->lchild)；

③ printf("％c"，T->data)； // 访问结点

④ InOrder(T->rchild);

⑤ }

⑥ } // InOrder

遍历序列

1．遍历二叉树的执行踪迹

三种递归遍历算法的搜索路线相同（如下图虚线所示）。

具体线路为：

从根结点出发，逆时针沿着二叉树外缘移动，对每个结点均途径三次，最后回到根结点。

2．遍历序列

A

/ \

B C

/ / \

D E F

图

（1） 中序序列（inorder traversal）

中序遍历二叉树时，对结点的访问次序为中序序列

【例】中序遍历上图所示的二叉树时，得到的中序序列为：

D B A E C F

（2） 先序序列（preorder traversal）

先序遍历二叉树时，对结点的访问次序为先序序列

【例】先序遍历上图所示的二叉树时，得到的先序序列为：

A B D C E F

（3） 后序序列（postorder traversal）

后序遍历二叉树时，对结点的访问次序为后序序列

【例】后序遍历上图所示的二叉树时，得到的后序序列为：

D B E F C A

（4）层次遍历（level traversal）二叉树的操作定义为：若二叉树为空，则退出，否则，按照树的结构，从根开始自上而下，自左而右访问每一个结点，从而实现对每一个结点的遍历

注意：

（1）在搜索路线中，若访问结点均是第一次经过结点时进行的，则是前序遍历；若访问结点均是在第二次(或第三次)经过结点时进行的，则是中序遍历(或后序遍历)。只要将搜索路线上所有在第一次、第二次和第三次经过的结点分别列表，即可分别得到该二叉树的前序序列、中序序列和后序序列。

（2）上述三种序列都是线性序列，有且仅有一个开始结点和一个终端结点，其余结点都有且仅有一个前趋结点和一个后继结点。为了区别于树形结构中前趋(即双亲)结点和后继(即孩子)结点的概念，对上述三种线性序列，要在某结点的前趋和后继之前冠以其遍历次序名称。

【例】上图所示的二叉树中结点C，其前序前趋结点是D，前序后继结点是E；中序前趋结点是E，中序后继结点是F；后序前趋结点是F，后序后继结点是A。但是就该树的逻辑结构而言，C的前趋结点是A，后继结点是E和F。

二叉链表的构造

1． 基本思想

基于先序遍历的构造，即以二叉树的先序序列为输入构造。

注意：

先序序列中必须加入虚结点以示空指针的位置。

【例】

建立上图所示二叉树，其输入的先序序列是：ABD∮∮∮CE∮∮F∮∮。

2． 构造算法

假设虚结点输入时以空格字符表示，相应的构造算法为：

void CreateBinTree (BinTree *T)

{ //构造二叉链表。T是指向根指针的指针，故修改*T就修改了实参(根指针)本身

char ch；

if((ch=getchar())=='') *T=NULL； //读人空格，将相应指针置空

else{ //读人非空格

*T=(BinTNode *)malloc(sizeof(BinTNode))； //生成结点

(*T)->data=ch；

CreateBinTree(&(*T)->lchild)； //构造左子树

CreateBinTree(&(*T)->rchild)； //构造右子树

}

}

注意：

调用该算法时，应将待建立的二叉链表的根指针的地址作为实参。

【例】

设root是一根指针(即它的类型是BinTree)，则调用CreateBinTree(&root)后root就指向了已构造好的二叉链表的根结点。

二叉树建立过程见http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/erchashujianli.htm

下面是关于二叉树的遍历、查找、删除、更新数据的代码(递归算法):

[code]

#include

using namespace std;

typedef int T;

class bst{

struct Node{

T data;

Node* L;

Node* R;

Node(const T& d, Node* lp=NULL, Node* rp=NULL):data(d),L(lp),R(rp){}

};

Node* root;

int num;

public:

bst():root(NULL),num(0){}

void clear(Node* t){

if(t==NULL) return;

clear(t->L);

clear(t->R);

delete t;

}

~bst(){clear(root);}

void clear(){

clear(root);

num = 0;

root = NULL;

}

bool empty(){return root==NULL;}

int size(){return num;}

T getRoot(){

if(empty()) throw "empty tree";

return root->data;

}

void travel(Node* tree){

if(tree==NULL) return;

travel(tree->L);

cout << tree->data << ' ';

travel(tree->R);

}

void travel(){

travel(root);

cout << endl;

}

int height(Node* tree){

if(tree==NULL) return 0;

int lh = height(tree->L);

int rh = height(tree->R);

return 1+(lh>rh?lh:rh);

}

int height(){

return height(root);

}

void insert(Node*& tree, const T& d){

if(tree==NULL)

tree = new Node(d);

else if(ddata)

insert(tree->L, d);

else

insert(tree->R, d);

}

void insert(const T& d){

insert(root, d);

num++;

}

Node*& find(Node*& tree, const T& d){

if(tree==NULL) return tree;

if(tree->data==d) return tree;

if(ddata)

return find(tree->L, d);

else

return find(tree->R, d);

}

bool find(const T& d){

return find(root, d)!=NULL;

}

bool erase(const T& d){

Node*& pt = find(root, d);

if(pt==NULL) return false;

combine(pt->L, pt->R);

Node* p = pt;

pt = pt->R;

delete p;

num--;

return true;

}

void combine(Node* lc, Node*& rc){

if(lc==NULL) return;

if(rc==NULL) rc = lc;

else combine(lc, rc->L);

}

bool update(const T& od, const T& nd){

Node* p = find(root, od);

if(p==NULL) return false;

erase(od);

insert(nd);

return true;

}

};

int main()

{

bst b;

cout << "input some integers:";

for(;;){

int n;

cin >> n;

b.insert(n);

if(cin.peek()=='\n') break;

}

b.travel();

for(;;){

cout << "input data pair:";

int od, nd;

cin >> od >> nd;

if(od==-1&&nd==-1) break;

b.update(od, nd);

b.travel();

}

}

[/code]

</endl<<endl;
</endl<
</endl<
</endl;
</a<<endl<<endl;
</endl<

</endl;

写出二叉树的先序遍历、中序遍历、后序遍历。

首先 观察这个二叉树
可见是这样的：1.以B为根节点的左子树 A根节点 以C为根节点的右子树
2.以D为根节点的左子树 B根节点 以E为根节点的右子树
3.以G为根节点的左子树 D根节点 以H为根节点的右子树
4.以K为根节点的左子树 C根节点 以F为根节点的右子树
5.以I为根节点的左子树 F根节点 右子树为空
6.左子树为空 I根节点 以J为根节点的右子树
接下来可以进行遍历了：
前序遍历 是 根 左子树 右子树：
即先是跟节点A 然后遍历 B子树 遍历完B子树后 再遍历C子树 即最后答案为：
ABDGHECKFIJ
中序遍历为 左子树 根 右子树
先遍历 B子树 遍历完了 再是A节点 然后是右子树 答案为：
GDHBEAKCIJF
后序遍历是 左子树 右子树 根
答案为：
GHDEBKJIFCA
先序输出:
A B D G H E C K F I J
中序输出:
G D H B E A K C I J F
后序输出:
G H D E B K J I F C A
前序：根、左子树、右子树 ABDGHECKFIJ
中序：左子树、根、右子树 GDHBEAKCIJF
后序：左子树、右子树、根 GHDEBKJIFCA
一、先序遍历：
1、访问根节点
2、前序遍历左子树
3、前序遍历右子树
二、中序遍历：
1、中序遍历左子树
2、访问根节点
3、中序遍历右子树
三、后序遍历：
1、后序遍历左子树
2、后序遍历右子树
3、访问根节点
下面介绍一下例子与方法：
1、画树求法：
第一步，根据前序遍历的特点，我们知道根结点为G
第二步，观察中序遍历ADEFGHMZ。其中root节点G左侧的ADEF必然是root的左子树，G右侧的HMZ必然是root的右子树。
第三步，观察左子树ADEF，左子树的中的根节点必然是大树的root的leftchild。在前序遍历中，大树的root的leftchild位于root之后，所以左子树的根节点为D。
第四步，同样的道理，root的右子树节点HMZ中的根节点也可以通过前序遍历求得。在前序遍历中，一定是先把root和root的所有左子树节点遍历完之后才会遍历右子树，并且遍历的左子树的第一个节点就是左子树的根节点。同理，遍历的右子树的第一个节点就是右子树的根节点。
第五步，观察发现，上面的过程是递归的。先找到当前树的根节点，然后划分为左子树，右子树，然后进入左子树重复上面的过程，然后进入右子树重复上面的过程。最后就可以还原一棵树了。该步递归的过程可以简洁表达如下：
1 确定根,确定左子树，确定右子树。
2 在左子树中递归。
3 在右子树中递归。
4 打印当前根。
那么，我们可以画出这个二叉树的形状：
那么，根据后序的遍历规则，我们可以知道，后序遍历顺序为：AEFDHZMG
二叉树的一些介绍：
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。
二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^{i-1}个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T，如果其终端结点数为n_0，度为2的结点数为n_2，则n_0=n_2+1。
一棵深度为k，且有2^k-1个节点称之为满二叉树；深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中，序号为1至n的节点对应时，称之为完全二叉树。

c++二叉树的几种遍历算法

遍历二叉树的所有结点且仅访问一次。按照根节点位置的不同分为前序遍历，中序遍历，后序遍历（除此之外还有层次遍历，但不常用，此处不做解释）。
1.前序遍历：根节点->左子树->右子树（根节点在前面）。
2.中序遍历：左子树->根节点->右子树（根节点在中间）。
3.后序遍历：左子树->右子树->根节点（根节点在后边）。
例如：求下面树的三种遍历：
前序遍历：abdefgc；
中序遍历：debgfac；
后序遍历：edgfbca。

二叉树的遍历算法

这里有二叉树先序、中序、后序三种遍历的非递归算法，此三个算法可视为标准算法。
1.先序遍历非递归算法
#define
maxsize
100
typedef
struct
{
Bitree
Elem[maxsize];
int
top;
}SqStack;
void
PreOrderUnrec(Bitree
t)
{
SqStack
s;
StackInit(s);
p=t;
while
(p!=null
||
!StackEmpty(s))
{
while
(p!=null)
//遍历左子树
{
visite(p->data);
push(s,p);
p=p->lchild;
}//endwhile
if
(!StackEmpty(s))
//通过下一次循环中的内嵌while实现右子树遍历
{
p=pop(s);
p=p->rchild;
}//endif
}//endwhile
}//PreOrderUnrec
2.中序遍历非递归算法
#define
maxsize
100
typedef
struct
{
Bitree
Elem[maxsize];
int
top;
}SqStack;
void
InOrderUnrec(Bitree
t)
{
SqStack
s;
StackInit(s);
p=t;
while
(p!=null
||
!StackEmpty(s))
{
while
(p!=null)
//遍历左子树
{
push(s,p);
p=p->lchild;
}//endwhile
if
(!StackEmpty(s))
{
p=pop(s);
visite(p->data);
//访问根结点
p=p->rchild;
//通过下一次循环实现右子树遍历
}//endif
}//endwhile
}//InOrderUnrec
3.后序遍历非递归算法
#define
maxsize
100
typedef
enum{L,R}
tagtype;
typedef
struct
{
Bitree
ptr;
tagtype
tag;
}stacknode;
typedef
struct
{
stacknode
Elem[maxsize];
int
top;
}SqStack;
void
PostOrderUnrec(Bitree
t)
{
SqStack
s;
stacknode
x;
StackInit(s);
p=t;
do
{
while
(p!=null)
//遍历左子树
{
x.ptr
=
p;
x.tag
=
L;
//标记为左子树
push(s,x);
p=p->lchild;
}
while
(!StackEmpty(s)
&&
s.Elem[s.top].tag==R)
{
x
=
pop(s);
p
=
x.ptr;
visite(p->data);
//tag为R，表示右子树访问完毕，故访问根结点
}
if
(!StackEmpty(s))
{
s.Elem[s.top].tag
=R;
//遍历右子树
p=s.Elem[s.top].ptr->rchild;
}
}while
(!StackEmpty(s));
}//PostOrderUnrec