二叉树三种遍历方式递归与非递归实现总结

浅浅的花香味﹌ 2022-09-17 14:27 151阅读 0赞

二叉树是一种非常重要的数据结构，很多其他数据机构都是基于二叉树的基础演变过来的。二叉树有前、中、后三种遍历方式，因为树的本身就是用递归定义的，因此采用递归的方法实现三种遍历，不仅代码简洁且容易理解，但其开销也比较大，而若采用非递归方法实现三种遍历，则要用栈来模拟实现（递归也是用栈实现的）。下面先简要介绍三种遍历方式的递归实现，再详细介绍三种遍历方式的非递归实现。

一、三种遍历方式的递归实现（比较简单，这里不详细讲解）

1、先序遍历——按照“根节点\-左孩子\-右孩子”的顺序进行访问。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** pre\_traverse(BTree pTree)  
2.  \{  
3.      **if**(pTree)  
4.      \{  
5.          printf("%c ",pTree->data);  
6.          **if**(pTree->pLchild)  
7.              pre\_traverse(pTree->pLchild);  
8.          **if**(pTree->pRchild)  
9.              pre\_traverse(pTree->pRchild);      
10.     \}  
11. \}

2、中序遍历——按照“左孩子-根节点-右孩子”的顺序进行访问。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** in\_traverse(BTree pTree)  
2.  \{  
3.      **if**(pTree)  
4.      \{  
5.          **if**(pTree->pLchild)  
6.              in\_traverse(pTree->pLchild);  
7.          printf("%c ",pTree->data);  
8.          **if**(pTree->pRchild)  
9.              in\_traverse(pTree->pRchild);   
10.     \}  
11. \}

3、后序遍历——按照“左孩子\-右孩子\-根节点”的顺序进行访问。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** beh\_traverse(BTree pTree)  
2.  \{  
3.      **if**(pTree)  
4.      \{  
5.          **if**(pTree->pLchild)  
6.              beh\_traverse(pTree->pLchild);  
7.          **if**(pTree->pRchild)  
8.              beh\_traverse(pTree->pRchild);      
9.          printf("%c ",pTree->data);  
10. \}

二、三种遍历方式的非递归实现

为了便于理解，这里以下图的二叉树为例，分析二叉树的三种遍历方式的实现过程。

![SouthEast][]

先序 A B D E C F

中序 D B E A F C

后序 D E B F C A

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

前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。
    方法有很多，这里只举一种，先定义栈结点的数据结构
    typedef struct{Node * p; int rvisited;}SNode //Node 是二叉树的结点结构，rvisited==1代表p所指向的结点的右结点已被访问过。
    
    lastOrderTraverse(BiTree bt){
    　　//首先，从根节点开始，往左下方走，一直走到头，将路径上的每一个结点入栈。
    　　p = bt;
    　　while(bt){
    　　　　push(bt, 0); //push到栈中两个信息，一是结点指针，一是其右结点是否被访问过
    　　　　bt = bt.lchild;
    　　}
    
    　　//然后进入循环体
    　　while(!Stack.empty()){ //只要栈非空
    　　　　sn = Stack.getTop(); // sn是栈顶结点
    
    　　　　//注意，任意一个结点N，只要他有左孩子，则在N入栈之后，N的左孩子必然也跟着入栈了(这个体现在算法的后半部分)，所以当我们拿到栈顶元素的时候，可以确信这个元素要么没有左孩子，要么其左孩子已经被访问过，所以此时我们就不关心它的左孩子了，我们只关心其右孩子。
    
    　　　　//若其右孩子已经被访问过，或是该元素没有右孩子，则由后序遍历的定义，此时可以visit这个结点了。
    　　　　if(!sn.p.rchild || sn.rvisited){
    　　　　　　p = pop();
    　　　　　　visit(p);
    　　　　}
    　　　　else //若它的右孩子存在且rvisited为0，说明以前还没有动过它的右孩子，于是就去处理一下其右孩子。
    　　　　{ 
    　　　　　　//此时我们要从其右孩子结点开始一直往左下方走，直至走到尽头，将这条路径上的所有结点都入栈。
    
    　　　　　　//当然，入栈之前要先将该结点的rvisited设成1，因为其右孩子的入栈意味着它的右孩子必将先于它被访问(这很好理解，因为我们总是从栈顶取出元素来进行visit)。由此可知，下一次该元素再处于栈顶时，其右孩子必然已被visit过了，所以此处可以将rvisited设置为1。
    　　　　　　sn.rvisited = 1;
    
    　　　　　　//往左下方走到尽头，将路径上所有元素入栈
    　　　　　　p = sn.p.rchild;
    　　　　　　while(p != 0){
    　　　　　　　　push(p, 0);
    　　　　　　　　p = p.lchild;
    　　　　　　}
    　　　　}//这一轮循环已结束，刚刚入栈的那些结点我们不必管它了，下一轮循环会将这些结点照顾的很好。
    　　}
    }

无注释版本：

前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。
    方法有很多，这里只举一种，先定义栈结点的数据结构
    typedef struct{Node * p; int rvisited;}SNode 
    
    lastOrderTraverse(BiTree bt){
    　　 　　p = bt;
    　　while(bt){
    　　　　push(bt, 0); 　　　　        bt = bt.lchild;
    　　}
    　　
    　　while(!Stack.empty()){ 
    　　　　sn = Stack.getTop(); 
    
    　　　　if(!sn.p.rchild || sn.rvisited){
    　　　　　　p = pop();
    　　　　　　visit(p);
    　　　　}
    　　　　else 
    　　　　{ 
    　　　　　　sn.rvisited = 1;
    
    　　　　　　p = sn.p.rchild;
    　　　　　　while(p != 0){
    　　　　　　　　push(p, 0);
    　　　　　　　　p = p.lchild;
    　　　　　　}
    　　　　}
    　　}
    }

[view plain]: http://blog.csdn.net/ns_code/article/details/12977901#
[SouthEast]: /images/20220828/2da4400f448e4d49a7a0ec58b925ade9.png