二叉树的几种遍历方式浅析：递归遍历/堆栈遍历/层序遍历/Morris遍历

最新推荐文章于 2024-08-15 17:11:26 发布
最新推荐文章于 2024-08-15 17:11:26 发布
阅读量4.3k 收藏 5
点赞数
分类专栏： Algorithm 文章标签： 算法 二叉树 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lavorange/article/details/20641041
版权

      在和树相关的算法中，二叉树的遍历起着举足轻重的作用，很多算法都能够以二叉树的遍历衍生出来，那么我们就从二叉树的建立开始，讲述二叉树的各种遍历方式。

一、二叉树的建立

二、二叉树递归遍历

三、二叉树非递归遍历

四、二叉树层序遍历

五、二叉树Morris遍历


一、二叉树的建立

      首先，如何在内存中生成一颗二叉树呢？我们要在内存中创建一个如下图所示的二叉树。

      

如上图所示，为了能让每个节点确认是否有左右孩子，我们对它进行扩展，也就是讲二叉树中每个节点的空指针引出一个虚结点，其值为一特定值，比如“#“。我们称这种处理后的二叉树为原二叉树的扩展二叉树。扩展二叉树就可以做到一个遍历序列确定一颗二叉树了。比如上图的前序遍历的前序遍历序列为："ABD#G##E##C#F##"。在内存中重建二叉树有两种方式：1.像上述所述的用扩展二叉树，根据前序遍历序列就能确定。2.根据前序遍历序列和中序遍历序列重建二叉树。本文采取第一种方式重建。

建立二叉树的代码如下：

<span style="font-size:14px;">#include<iostream>

using namespace std;

typedef char TElemType;

typedef struct BiTNode
{
    TElemType val;
    BiTNode *lchild , *rchild;
    BiTNode(TElemType x):val(x),lchild(NULL),rchild(NULL) {}
}tBiTNode;

/*input : ABD#G##E##C#F##*/
void createTree(tBiTNode *&T)
{
     TElemType x;
     cin>>x;
     if(x=='#')
     {
         T = NULL;          
     }
     else
     {
         T = new BiTNode(x);
         createTree(T->lchild);
         createTree(T->rchild);
     }
}

/*Pre Order Traverse*/
void PreOrderTraverse(BiTNode *T)
{
    if(T==NULL)   return;
    cout<<T->val;
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}

int main()
{
    tBiTNode *p;
    createTree(p)    ;
    PreOrderTraverse(p);
    system("pause");
    return 0;
}</span>

结果：



二、二叉树的递归遍历

     对于上图的二叉树，用递归的方法就行前序中序后序遍历。

<span style="font-size:14px;">#include<iostream>

using namespace std;

typedef char TElemType;

typedef struct BiTNode
{
    TElemType val;
    BiTNode *lchild , *rchild;
    BiTNode(TElemType x):val(x),lchild(NULL),rchild(NULL) {}
}tBiTNode;

/*input : ABD#G##E##C#F##*/
void createTree(tBiTNode *&T)
{
     TElemType x;
     cin>>x;
     if(x=='#')
     {
         T = NULL;          
     }
     else
     {
         T = new BiTNode(x);
         createTree(T->lchild);
         createTree(T->rchild);
     }
}

/*Pre Order Traverse*/
void PreOrderTraverse(BiTNode *T)
{
    if(T==NULL)   return;
    cout<<T->val;
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}

/*In Order Traverse*/
void InOrderTraverse(BiTNode *T)
{
    if(T==NULL)     return ;
    InOrderTraverse(T->lchild);
    cout<<T->val;
    InOrderTraverse(T->rchild);
} 

/*Post Order Traverse*/
void PostOrderTraverse(BiTNode *T)
{
    if(T==NULL)     return ;
    PostOrderTraverse(T->lchild);
    PostOrderTraverse(T->rchild);
    cout<<T->val;
}

int main()
{
    tBiTNode *p;
    createTree(p)    ;
    cout<<"Pre Order Traverse:"<<endl;
    PreOrderTraverse(p);
    cout<<"\nIn Order Traverse:"<<endl;
    InOrderTraverse(p);
    cout<<"\nPost Order Traverse:"<<endl;
    PostOrderTraverse(p); 
    cout<<endl;
    system("pause");
    return 0;
}</span>


结果：



三、二叉树的非递归遍历（堆栈遍历）

非递归前序遍历代码：

<span style="font-size:14px;">/*Pre Order Traverse with non-recursion algorithm*/
void PreOrderTraverse(BiTNode *T)
{
    if( T==NULL ) return ;
    vector<TElemType> vec; //contain the result sequence 
    stack<BiTNode *> stk;
    stk.push(T); //push the root into the stack 
    while( !stk.empty() )
    {
         BiTNode *cur = stk.top();
         stk.pop();
         vec.push_back(cur->val);
         if(cur->rchild!=NULL)
         {
             stk.push(cur->rchild);
         }
         if(cur->lchild!=NULL)
         {
             stk.push(cur->lchild);
         }
    }   
    print(vec);  //print the result 
}</span>
分析：前序遍历的顺序为“中--左--右”，那么指针从根节点开始，就是中间的节点，也是结果的第一个节点，然后依次是左子树和右子树的压栈和弹栈。值得注意的是，在压栈的时候首先压入的是右子树的根节点，然后才是左子树的根节点，是因为栈是先进后出的数据结构，后压入左子树才能先弹出，相信代码写的足够清楚，稍微揣测一下就能够理解，重点是非递归后序遍历。


非递归中序遍历代码：

/*In Order Traverse with non-recursion algorithm*/
void InOrderTraverse(BiTNode *T)
{
    if( T==NULL ) return ;
    stack<BiTNode *> stk;
    vector<TElemType> vec;
    BiTNode *cur = T->lchild;
    stk.push(T);
    while( cur!=NULL || !stk.empty() )
    {
        /*search the most left pointer by cur*/   
        while( cur!=NULL )
        {
            stk.push(cur);
            cur = cur->lchild;  
        }
        cur = stk.top();
        stk.pop();
        vec.push_back(cur->val);
        cur = cur->rchild; //traverse the right subtree 
    }
    print(vec);
}
分析：首先根据当前的指针cur找到最左面的节点，并把路径上的结点的指针依次压栈，弹栈，之后去用相同的方法遍历右子树，最终完成中序遍历。


非递归后序遍历代码：

/*Post Order Traverse with non-recursion algorithm*/<strong>
</strong>void PostOrderTraverse(BiTNode *T)
{
    if(T==NULL) return ;
    vector<TElemType> vec;
    stack<BiTNode *> stk;
    stk.push(T);
    while( !stk.empty() )
    {
        BiTNode *cur = stk.top();
        stk.pop();
        vec.push_back(cur->val);
        if( cur->lchild!=NULL )
        {
            stk.push(cur->lchild);
        }
        if( cur->rchild!=NULL )
        {
            stk.push(cur->rchild);
        }
    }
    reverse( vec.begin(),vec.end() ); //reverse the result sequence 
    print(vec);
}
重点分析：后序遍历的代码基本上和前序遍历的代码一致，唯一不同的就是左右子树的压栈顺序以及最终的将序列逆序两个地方。解释一下原因，前序遍历的过程为：中-左-右；后序遍历的过程为：左-右-中。做个变换：“中-左-右”==>"中-右-左"==>"左-右-中"。也就是说，后序遍历的结果序列分为两步：1.前序遍历的一个改版：先访问根节点，遍历右子树，再遍历左子树。2.将(1)的结果逆序即可。


完整代码：

#include<iostream>
#include<stack>
#include<cstdlib>
#include<algorithm>
#include<vector>

using namespace std;

typedef char TElemType;

typedef struct BiTNode
{
    TElemType val;
    BiTNode *lchild , *rchild;
    BiTNode(TElemType x):val(x),lchild(NULL),rchild(NULL) {}
}tBiTNode;

/*print the result*/
void print( vector<TElemType> &vec )
{
    int len = vec.size();
    for( int i=0;i<len;i++ )         
    {
        cout<<vec[i];     
    }
    cout<<endl;
}

/*input : ABD#G##E##C#F##*/
void createTree(tBiTNode *&T)
{
     TElemType x;
     cin>>x;
     if(x=='#')
     {
         T = NULL;          
     }
     else
     {
         T = new BiTNode(x);
         createTree(T->lchild);
         createTree(T->rchild);
     }
}

/*Pre Order Traverse with non-recursion algorithm*/
void PreOrderTraverse(BiTNode *T)
{
    if( T==NULL ) return ;
    vector<TElemType> vec; //contain the result sequence 
    stack<BiTNode *> stk;
    stk.push(T); //push the root into the stack 
    while( !stk.empty() )
    {
         BiTNode *cur = stk.top();
         stk.pop();
         vec.push_back(cur->val);
         if(cur->rchild!=NULL)
         {
             stk.push(cur->rchild);
         }
         if(cur->lchild!=NULL)
         {
             stk.push(cur->lchild);
         }
    }   
    print(vec);  //print the result 
}

/*In Order Traverse with non-recursion algorithm*/
void InOrderTraverse(BiTNode *T)
{
    if( T==NULL ) return ;
    stack<BiTNode *> stk;
    vector<TElemType> vec;
    BiTNode *cur = T->lchild;
    stk.push(T);
    while( cur!=NULL || !stk.empty() )
    {
        /*search the most left pointer by cur*/   
        while( cur!=NULL )
        {
            stk.push(cur);
            cur = cur->lchild;  
        }
        cur = stk.top();
        stk.pop();
        vec.push_back(cur->val);
        cur = cur->rchild; //traverse the right subtree 
    }
    print(vec);
} 

/*Post Order Traverse with non-recursion algorithm*/
void PostOrderTraverse(BiTNode *T)
{
    if(T==NULL) return ;
    vector<TElemType> vec;
    stack<BiTNode *> stk;
    stk.push(T);
    while( !stk.empty() )
    {
        BiTNode *cur = stk.top();
        stk.pop();
        vec.push_back(cur->val);
        if( cur->lchild!=NULL )
        {
            stk.push(cur->lchild);
        }
        if( cur->rchild!=NULL )
        {
            stk.push(cur->rchild);
        }
    }
    reverse( vec.begin(),vec.end() ); //reverse the result sequence 
    print(vec);
}

int main()
{
    tBiTNode *p;
    createTree(p)    ;
    cout<<"Pre Order Traverse:"<<endl;
    PreOrderTraverse(p);
    cout<<"\nIn Order Traverse:"<<endl;
    InOrderTraverse(p);
    cout<<"\nPost Order Traverse:"<<endl;
    PostOrderTraverse(p); 
    cout<<endl;
    system("pause");
    return 0;
}

结果和递归一致。


四、二叉树的层序遍历

层序遍历代码：

/*Level Traverse*/
void LevelTraverse(BiTNode *T)
{
    queue<BiTNode *> que;
    if( T==NULL )  return ;
    vector<TElemType> vec;
    que.push(T);
    while( !que.empty() )
    {
        BiTNode *cur = que.front();
        que.pop();
        vec.push_back(cur->val);
        if( cur->lchild!=NULL )
        {
            que.push(cur->lchild);
        } 
        if( cur->rchild!=NULL )
        {
            que.push(cur->rchild);
        }
    }
    print(vec);
}

分析：层序遍历就是相当于一个从根节点开始的BFS，那么可以想到用到队列，首先将根节点入队列，然后出队列，将其左右两个孩子的节点指针入队列，依次出队列，保持值，入左右孩子节点的指针，重复直到队列为空。


结果：



五、二叉树的Morris遍历

参考：http://daiziguizhong.qiniudn.com/article22.html 


转载请注明出处：http://blog.csdn.net/lavorange/article/details/20641041 




忆之独秀
关注
专栏目录
go实现“二叉树遍历”
weixin_42178081的博客
08-28 3867
1.二叉树的常用性质 &lt;1&gt;.在二叉树的第i层上最多有2i-1个节点 。（i&gt;=1） &lt;2&gt;.二叉树中如果深度为k(有k层),那么最多有2k-1个节点。(k&gt;=1） &lt;3&gt;.若二叉树按照从上到下从左到右依次编号，则若某节点编号为k，则其左右子树根节点编号分别为2k和2k+1; &lt;4&gt;.二叉树分类：满二叉树，完全二叉树 满二叉...
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。
07-01
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，...
二叉树遍历(递归)
weixin_33919941的博客
05-04 64
// 测试二叉树遍历，递归算法 public class TestBinaryTree { public static void main（String[] args） { Node&lt;String&gt; g = new Node&lt;String&gt;（"G", null, null）； Node&lt;String&gt; e = new...
【数据结构】二叉树（二）遍历
最新发布
m0_73107796的博客
08-15 1628
讲解二叉树的前序遍历、中序遍历、后序遍历及层序遍历的递归与非递归遍历方法。
二叉树递归遍历
weixin_34168880的博客
08-30 81
1 /* 模块名 : 树 2 /* 文件名 : btree.cpp 3 /* 功能描述 : 二叉树的递归遍历 4 5 /* 备注 : 输入示例与输出结果 6 /* e.g. input : ABD###CE#F### 7 /* bi-tree : 8 /* A ...
二叉树遍历（递归）
ShootCode
09-03 5913
二叉树又称为红黑树，是一种常用的数据结构，而二叉树的遍历则是一种非常基本的操作。遍历二叉树的方式有两大类：递归和非递归。递归方式算法较为简便，并且更便于理解，非递归方式则需要对二叉树的遍历次序有较为深入的理解，并且非递归方式相较于递归方式除了前序，中序和后序递归以外还有一种广度优先遍历方式。二叉树又称为红黑树，是一种每个节点最多有两个子节点的数据结构，两个节点分别有左右之分，称为左子树和右子树，并且
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
遍历二叉树的4个非递归算法.rar_binary tree_二叉树_二叉树 非递归 遍历_递归_遍历 CSharp
09-14
本资源"遍历二叉树的4个非递归算法.rar"提供了C#语言实现的这四种非递归遍历方法，对于学习者来说是非常宝贵的资料。 1. **前序遍历**（Root-Left-Right）： 在前序遍历中，我们首先访问根节点，然后递归地遍历左...
C 语言二叉树几种遍历方法详解及实例
08-31
创建二叉树通常有两种方式：顺序存储和链式存储。顺序存储，即数组表示，容易造成空间浪费，因为每个节点都占据固定位置，即使部分节点为空。链式存储通过结构体来表示节点，每个节点包含数据和指向左右子节点的指针...
二叉树遍历方法详解：递归与非递归、层次遍历
本文档主要介绍了二叉树的基本操作，包括递归和非递归遍历算法，以及层次遍历和计算叶子节点数。二叉树是一种数据结构，每个节点最多有两个子节点，通常被表示为一个包含数据和指向左右子节点指针的结构。文档中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值