二叉树的遍历是指按照某种顺序访问二叉树中的每个结点，使每个结点被访问一次且仅被访问一次。遍历是二叉树中经常要用到的一种操作。因为在实际应用问题中，常常需要按一定顺序对二叉树中的每个结点逐个进行访问，查找具有某一特点的结点，然后对这些满足条件的结点进行处理。
通过一次完整的遍历，可使二叉树中结点信息由非线性排列变为某种意义上的线性序列。也就是说，遍历操作使非线性结构线性化。
由二叉树的定义可知，一棵由根结点、根结点的左子树和根结点的右子树三部分组成。因此，只要依次遍历这三部分，就可以遍历整个二叉树。若以D、L、R 分别表示访问根结点、遍历根结点的左子树、遍历根结点的右子树，则二叉树的遍历方式有六种：DLR、LDR、LRD、DRL、RDL 和RLD。如果限定先左后右，则只有前三种方式，即DLR（称为先序遍历）、LDR（称为中序遍历）和LRD（称为后序遍历）。
1．先序遍历（DLR）
先序遍历的递归过程为：若二叉树为空，遍历结束。否则，
（1） 访问根结点；
（2） 先序遍历根结点的左子树；
（3） 先序遍历根结点的右子树。
先序遍历二叉树的递归算法如下：
void PreOrder(BiTree bt) /*先序遍历二叉树bt*/
{
if (bt==NULL) return; /*递归调用的结束条件*/
Visite(bt->data); /*访问结点的数据域*/
PreOrder(bt->lchild); /*先序递归遍历bt 的左子树*/
PreOrder(bt->rchild); /*先序递归遍历bt 的右子树*/
}
2．中序遍历（LDR）
中序遍历的递归过程为：若二叉树为空，遍历结束。否则，
（1）中序遍历根结点的左子树；
（2）访问根结点；
（3）中序遍历根结点的右子树。
中序遍历二叉树的递归算法如下：
void InOrder(BiTree bt) /*中序遍历二叉树bt*/
{
if (bt==NULL) return; /*递归调用的结束条件*/
InOrder(bt->lchild); /*中序递归遍历bt 的左子树*/
Visite(bt->data); /*访问结点的数据域*/
InOrder(bt->rchild); /*中序递归遍历bt 的右子树*/
}
3．后序遍历（LRD）
后序遍历的递归过程为：若二叉树为空，遍历结束。否则，
（1）后序遍历根结点的左子树；
（2）后序遍历根结点的右子树。
（3）访问根结点；
后序遍历二叉树的递归算法如下：
void PostOrder(BiTree bt) /*后序遍历二叉树bt*/
{
if (bt==NULL) return; /*递归调用的结束条件*/
PostOrder(bt->lchild); /*后序递归遍历bt 的左子树*/
PostOrder(bt->rchild); /*后序递归遍历bt 的右子树*/
Visite(bt->data); /*访问结点的数据域*/
}
4．层次遍历
所谓二叉树的层次遍历，是指从二叉树的第一层（根结点）开始，从上至下逐层遍历，在同一层中，则按从左到右的顺序对结点逐个访问。
下面讨论层次遍历的算法。
由层次遍历的定义可以推知，在进行层次遍历时，对一层结点访问完后，再按照它们的访问次序对各个结点的左孩子和右孩子顺序访问，这样一层一层进行，先遇到的结点先访问，这与队列的操作原则比较吻合。因此，在进行层次遍历时，可设置一个队列结构，遍历从二叉树的根结点开始，首先将根结点指针入队列，然后从对头取出一个元素，每取一个元素，执行下面两个操作：
（1） 访问该元素所指结点；
（2） 若该元素所指结点的左、右孩子结点非空，则将该元素所指结点的左孩子指针和右孩子指针顺序入队。
此过程不断进行，当队列为空时，二叉树的层次遍历结束。
在下面的层次遍历算法中，二叉树以二叉链表存放，一维数组Queue[MAXNODE]用以实现队列，变量front 和rear 分别表示当前对首元素和队尾元素在数组中的位置。
void LevelOrder(BiTree bt) /*层次遍历二叉树bt*/
{
BiTree Queue[MAXNODE];
int front,rear;
if (bt==NULL)
return;
front=-1;
rear=0;
queue[rear]=bt;
while(front!=rear)
{
front++;
Visite(queue[front]->data); /*访问队首结点的数据域*/
if (queue[front]->lchild!=NULL) /*将队首结点的左孩子结点入队列*/
{
rear++;
queue[rear]=queue[front]->lchild;
}
if (queue[front]->rchild!=NULL) /*将队首结点的右孩子结点入队列*/
{
rear++;
queue[rear]=queue[front]->rchild;
}
}
}
二叉树遍历的非递归实现
对二叉树进行先序、中序和后序遍历都是从根结点开始的，且在遍历过程中经过结点的路线是一样的，只是访问的时机不同而已。然而，这一路线正是从根结点开始沿左子树深入下去，当深入到最左端，无法再深入
下去时，则返回，再逐一进入刚才深入时遇到结点的右子树，再进行如此的深入和返回，直到最后从根结点的右子树返回到根结点为止。先序遍历是在深入时遇到结点就访问，中序遍历是在从左子树返回时遇到结点访问，后序遍历是在从右子树返回时遇到结点访问。
在这一过程中，返回结点的顺序与深入结点的顺序相反，即后深入先返回，正好符合栈结构后进先出的点。因此，可以用栈来帮助实现这一遍历路线。其过程如下。在沿左子树深入时，深入一个结点入栈一个结点，若为先序遍历，则在入栈之前访问之；当沿左分支深入不下去时，则返回，即从堆栈中弹出前面压入的结点，若为中序遍历，则此时访问该结点，然后从该结点的右子树继续深入；若为后序遍历，则将此结点再次入栈，然后从该结点的右子树继续深入，与前面类同，仍为深入一个结点入栈一个结点，深入不下去再返回，直到第二次从栈里弹出该结点，才访问之。
1. 先序遍历的非递归实现
在下面算法中，二叉树以二叉链表存放，一维数组 stack[MAXNODE] 用以实现栈，变量top 用来表示当前栈顶的位置。
void NRPreOrder(BiTree bt) /*非递归先序遍历二叉树*/
{
BiTree stack[MAXNODE],p;
int top;
if (bt==NULL)
return;
top=0;
p=bt;
while(!(p==NULL&&top==0))
{
while(p!=NULL)
{
Visite(p->data); /*访问结点的数据域*/
if (top<MAXNODE-1) /*将当前指针p 压栈*/
{
stack[top]=p;
top++;
}
else
{
printf("栈溢出")；
return;
}
p=p->lchild; /*指针指向p 的左孩子*/
}
if (top<=0)
return; /*栈空时结束*/
else
{
top--;
p=stack[top]; /*从栈中弹出栈顶元素*/
p=p->rchild; /*指针指向p 的右孩子结点*/
}
}
}
2. 中序遍历的非递归实现
中序遍历的非递归算法的实现，只需将先序遍历的非递归算法中的 Visite(p->data) 移到 p=stack[top] 和 p=p->rchild 之间即可。
3. 后序遍历的非递归实现
由前面的讨论可知，后序遍历与先序遍历和中序遍历不同，在后序遍历过程中，结点在第一次出栈后，还需再次入栈，也就是说，结点要入两次栈，出两次栈，而访问结点是在第二次出栈时访问。因此，为了区别同一个结点指针的两次出栈，设置一标志flag，令：
flag = 1 -> 第一次出栈，结点不能访问
flag = 2 -> 第二次出栈，结点可以访问
当结点指针进、出栈时，其标志flag 也同时进、出栈。因此，可将栈中元素的数据类型定义为指针和标志flag 合并的结构体类型。定义如下：
typedef struct
{
BiTree link;
int flag;
} stacktype;
后序遍历二叉树的非递归算法如下。在算法中，一维数组 stack[MAXNODE] 用于实现栈的结构，指针变量p 指向当前要处理的结点，整型变量top 用来表示当前栈顶的位置，整型变量 sign 为结点 p 的标志量。
void NRPostOrder(BiTree bt) /*非递归后序遍历二叉树bt*/
{
stacktype stack[MAXNODE];
BiTree p;
int top,sign;
if (bt==NULL)
return;
top=-1 /*栈顶位置初始化*/
p=bt;
while (!(p==NULL && top==-1))
{
if (p!=NULL) /*结点第一次进栈*/
{
top++;
stack[top].link=p;
stack[top].flag=1;
p=p->lchild; /*找该结点的左孩子*/
}
else
{
p=stack[top].link;
sign=stack[top].flag;
top--;
if (sign==1) /*结点第二次进栈*/
{
top++;
stack[top].link=p;
stack[top].flag=2; /*标记第二次出栈*/
p=p->rchild;
}
else
{
Visite(p->data); /*访问该结点数据域值*/
p=NULL;
}
}
}
}
由遍历序列恢复二叉树
从前面讨论的二叉树的遍历知道，任意一棵二叉树结点的先序序列和中序序列都是唯一的。反过来，若已知结点的先序序列和中序序列，能否确定这棵二叉树呢？这样确定的二叉树是否是唯一的呢？回答是肯定的。
根据定义，二叉树的先序遍历是先访问根结点，其次再按先序遍历方式遍历根结点的左子树，最后按先序遍历方式遍历根结点的右子树。这就是说，在先序序列中，第一个结点一定是二叉树的根结点。另一方面，中序遍历是先遍历左子树，然后访问根结点，最后再遍历右子树。这样，根结点在中序序列中必然将中序序列分割成两个子序列，前一个子序列是根结点的左子树的中序序列，而后一个子序列是根结点的右子树的中序序列。根据这两个子序列，在先序序列中找到对应的左子序列和右子序列。在先序序列中，左子序列的第一个结点是左子树的根结点，右子序列的第一个结点是右子树的根结点。这样，就确定了二叉树的三个结点。同时，左子树和右子树的根结点又可以分别把左子序列和右子序列划分成两个子序列，如此递归下去，当取尽先序序列中的结点时，便可以得到一棵二叉树。
同样的道理，由二叉树的后序序列和中序序列也可唯一地确定一棵二叉树。因为，依据后序遍历和中序遍历的定义，后序序列的最后一个结点，就如同先序序列的第一个结点一样，可将中序序列分成两个子序列，分别为这个结点的左子树的中序序列和右子树的中序序列，再拿出后序序列的倒数第二个结点，并继续分割中序序列，如此递归下去，当倒着取取尽后序序列中的结点时，便可以得到一棵二叉树。
typedef struct _treenode
{
char data;
struct _treenode *left;
struct _treenode *right;
} treenode;
/*
函数名称：pre_mid_tree
函数功能：给定二叉树的先序与中序序列，建立二叉树。
输入参数: treenode *tree：二叉树的结点tree
char pre[]：存储了二叉树的先序序列的字符数组
char mid[]：存储了二叉树的中序序列的字符数组
int lp, int rp：二叉树的先序序列在数组pre中的左右边界
int lm, int rm：二叉树的中序序列在数组mid中的左右边界
*/
treenode * pre_mid_tree(treenode *tree, char pre[], char mid[],
int lp, int rp, int lm, int rm)
{
int pos;
int len;
tree = (treenode *)malloc(sizeof(treenode));
tree->data = pre[lp];
tree->left = tree->right = NULL;
pos = lm;
while(mid[pos] != pre[lp])
pos++;
len = pos - lm;
if(pos > lm)
tree->left = pre_mid_tree(tree->left, pre, mid,
lp+1, lp+len, lm, pos-1);
if(pos < rm)
tree->right = pre_mid_tree(tree->right, pre, mid,
lp+len+1, rp, pos+1, rm);
return tree;
}
/*
函数名称：post_mid_tree
函数功能：给定二叉树的后序与中序序列，建立二叉树。
输入参数: treenode *tree：二叉树的结点tree
char post[]：存储了二叉树的后序序列的字符数组
char mid[]：存储了二叉树的中序序列的字符数组
int lp, int rp：二叉树的后序序列在数组post中的左右边界
int lm, int rm：二叉树的中序序列在数组mid中的左右边界
*/
treenode * post_mid_tree(treenode *tree, char post[], char mid[],
int lp, int rp, int lm, int rm)
{
int pos;
int len;
tree = (treenode *)malloc(sizeof(treenode));
tree->data = post[rp];
tree->left = tree->right = NULL;
pos = lm;
while(mid[pos] != post[rp])
pos++;
len = pos - lm;
if(pos > lm)
tree->left = post_mid_tree(tree->left, post, mid,
lp, lp+len-1, lm, pos-1);
if(pos < rm)
tree->right = post_mid_tree(tree->right, post, mid,
lp+len, rp-1, pos+1, rm);
return tree;
}
不用栈的二叉树遍历的非递归方法
前面介绍的二叉树的遍历算法可分为两类，一类是依据二叉树结构的递归性，采用递归调用的方式来实现；另一类则是通过堆栈或队列来辅助实现。采用这两类方法对二叉树进行遍历时，递归调用和栈的使用都带来额外空间增加，递归调用的深度和栈的大小是动态变化的，都与二叉树的高度有关。因此，在最坏的情况下，即二叉树退化为单支树的情况下，递归的深度或栈需要的存储空间等于二叉树中的结点数。
还有一类二叉树的遍历算法，就是不用栈也不用递归来实现。常用的不用栈的二叉树遍历的非递归方法有以下三种：
（1）对二叉树采用三叉链表存放，即在二叉树的每个结点中增加一个双亲域parent，这样，在遍历深入到不能再深入时，可沿着走过的路径回退到任何一棵子树的根结点，并再向另一方向走。由于这一方法的实现是在每个结点的存储上又增加一个双亲域，故其存储开销就会增加。
（2）采用逆转链的方法，即在遍历深入时，每深入一层，就将其再深入的孩子结点的地址取出，并将其双亲结点的地址存入，当深入不下去需返回时，可逐级取出双亲结点的地址，沿原路返回。虽然此种方法是在二叉链表上实现的，没有增加过多的存储空间，但在执行遍历的过程中改变子女指针的值，这既是以时间换取空间，同时当有几个用户同时使用这个算法时将会发生问题。
（3）在线索二叉树上的遍历，即利用具有n 个结点的二叉树中的叶子结点和一度结点的n＋1 个空指针域，来存放线索，然后在这种具有线索的二叉树上遍历时，就可不需要栈，也不需要递归了。
评论 1
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
