C++编程练习(17)----“二叉树非递归遍历的实现“

最新推荐文章于 2021-05-19 21:00:10 发布
最新推荐文章于 2021-05-19 21:00:10 发布
阅读量542 收藏 1
点赞数
分类专栏： 【数据结构与算法】

二叉树的非递归遍历

最近看书上说道要掌握二叉树遍历的6种编写方式，之前只用递归方式编写过，这次就用非递归方式编写试一试。

C++编程练习(8)----“二叉树的建立以及二叉树的三种遍历方式“（前序遍历、中序遍历、后续遍历）

递归的思想也就是栈的思想，既然不用递归，那就改用栈的方式。



“递归=栈”



1、前序遍历

前序遍历按照“根结点-左孩子-右孩子”的顺序进行访问。

a）递归实现前序遍历：

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void PreOrderTraverse(BiTNode *T)   /*递归前序遍历*/  
  2. {  
  3.     if (T==NULL)  
  4.         return;  
  5.     std::cout<<T->data<<"\t";  
  6.     PreOrderTraverse(T->lchild);  
  7.     PreOrderTraverse(T->rchild);  
  8. }  

b）非递归实现前序遍历：

对于根结点P：
1)访问结点P，并将结点P入栈;
2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
3)直到P为NULL并且栈为空，则遍历结束。

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void nPreOrderTraverse(BiTNode *T)  /*非递归前序遍历*/  
  2. {  
  3.     if (T==NULL)  
  4.         return;  
  5.     BiTNode *p;  
  6.     p = T;  
  7.     std::stack<BiTNode*> stk;  
  8.     while(p!=NULL||!stk.empty())  
  9.     {  
  10.         while(p!=NULL)  
  11.         {  
  12.             std::cout<<p->data<<"\t";  
  13.             stk.push(p);  
  14.             p = p->lchild;  
  15.         }  
  16.         if(!stk.empty())  
  17.         {  
  18.             p = stk.top();  
  19.             stk.pop();  
  20.             p = p->rchild;  
  21.         }  
  22.     }     
  23. }  

2、中序遍历

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

a）递归实现中序遍历

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void InOrderTraverse(BiTNode *T)    /*递归中序遍历*/  
  2. {  
  3.     if (T==NULL)  
  4.         return;  
  5.     InOrderTraverse(T->lchild);  
  6.     std::cout<<T->data<<"\t";  
  7.     InOrderTraverse(T->rchild);  
  8. }  

b）非递归实现中序遍历

对于根结点P：
1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；
2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；
3)直到P为NULL并且栈为空则遍历结束。

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void nInOrderTraverse(BiTNode *T)   /*非递归中序遍历*/  
  2. {  
  3.     if(T==NULL)  
  4.         return;  
  5.     std::stack<BiTNode*> stk;  
  6.     BiTNode* p;  
  7.     p = T;  
  8.     while(p!=NULL || !stk.empty())  
  9.     {  
  10.         while(p!=NULL)  
  11.         {  
  12.             stk.push(p);  
  13.             p = p->lchild;  
  14.         }  
  15.         if(!stk.empty())  
  16.         {  
  17.             p = stk.top();  
  18.             stk.pop();  
  19.             std::cout<<p->data<<"\t";  
  20.             p = p->rchild;  
  21.         }  
  22.     }  
  23. }  

3、后序遍历

后序遍历按照“左孩子-右孩子-根结点”的顺序进行访问。

a）递归实现后序遍历

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void PostOrderTraverse(BiTNode *T)  /*递归后序遍历*/  
  2. {  
  3.     if(T==NULL)  
  4.             return;  
  5.     PostOrderTraverse(T->lchild);  
  6.     PostOrderTraverse(T->rchild);  
  7.     std::cout<<T->data<<"\t";  
  8. }  

b）非递归实现后序遍历

这里实现略复杂，当初想出来的方法过于笨重，后参考http://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html，改写如下：

要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

对于根结点P：

1)将P入栈，设置当前结点 cur ；

2)将当前的 cur 置为栈顶结点，如果 cur 不存在左孩子和右孩子，或者 cur 存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则可以直接访问该结点并进行出栈操作。否则将 cur 的右孩子和左孩子依次入栈；

3)直到栈为空则遍历结束。

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void nPostOrderTraverse(BiTNode *T)     /*非递归后序遍历*/  
  2. {  
  3.     if(T==NULL)  
  4.         return;  
  5.     BiTNode* cur;       /*当前结点*/  
  6.     BiTNode* pre = NULL;        /*前一次输出的结点*/  
  7.     std::stack<BiTNode*> stk;  
  8.     stk.push(T);  
  9.     while(!stk.empty())  
  10.     {  
  11.         cur = stk.top();  
  12.         if((cur->lchild==NULL && cur->rchild==NULL) ||  
  13.             (pre!=NULL && (cur->lchild==pre || cur->rchild==pre)))      
  14.         {                               /*如果当前结点没有孩子结点或者孩子节点都已被访问过*/  
  15.             std::cout<<cur->data<<"\t";  
  16.             stk.pop();  
  17.             pre = cur;  
  18.         }  
  19.         else  
  20.         {  
  21.             if(cur->rchild!=NULL)  
  22.                 stk.push(cur->rchild);  
  23.             if(cur->lchild!=NULL)  
  24.                 stk.push(cur->lchild);  
  25.         }  
  26.     }  
  27. }  

4、完整测试代码

1)BiTree.h头文件

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /* BiTree.h头文件 */  
  2. #include<iostream>  
  3. #include<stack>  
  4. typedef char TElemType;  
  5.   
  6. class BiTNode{                  /*创建结点类，使用的是左右孩子表示法*/  
  7. public:  
  8.     BiTNode():data(0),lchild(NULL),rchild(NULL){}  
  9.     TElemType data;  
  10.     BiTNode *lchild,*rchild;  
  11. };  
  12.   
  13. void CreateBiTree(BiTNode **T)      /*二叉树的建立，这里形参用的是双指针，需要注意*/  
  14. {                                           /*这里输入的是一个扩展二叉树，每个结点若有空指针，*/  
  15.     TElemType ch;                               /*则将其值设为一个特定值，本代码中是'#'*/  
  16.     std::cin>>ch;  
  17.     std::cin.clear();  
  18.     if(ch=='#')  
  19.         *T=NULL;  
  20.     else  
  21.     {  
  22.         *T=new BiTNode;  
  23.         if(!*T)  
  24.             exit(1);  
  25.         (*T)->data=ch;  
  26.         CreateBiTree(&(*T)->lchild);  
  27.         CreateBiTree(&(*T)->rchild);  
  28.     }  
  29. }  
  30.   
  31. void PreOrderTraverse(BiTNode *T)   /*递归前序遍历*/  
  32. {  
  33.     if (T==NULL)  
  34.         return;  
  35.     std::cout<<T->data<<"\t";  
  36.     PreOrderTraverse(T->lchild);  
  37.     PreOrderTraverse(T->rchild);  
  38. }  
  39.   
  40. void nPreOrderTraverse(BiTNode *T)  /*非递归前序遍历*/  
  41. {  
  42.     if (T==NULL)  
  43.         return;  
  44.     BiTNode *p;  
  45.     p = T;  
  46.     std::stack<BiTNode*> stk;  
  47.     while(p!=NULL||!stk.empty())  
  48.     {  
  49.         while(p!=NULL)  
  50.         {  
  51.             std::cout<<p->data<<"\t";  
  52.             stk.push(p);  
  53.             p = p->lchild;  
  54.         }  
  55.         if(!stk.empty())  
  56.         {  
  57.             p = stk.top();  
  58.             stk.pop();  
  59.             p = p->rchild;  
  60.         }  
  61.     }     
  62. }  
  63.   
  64.   
  65. void InOrderTraverse(BiTNode *T)    /*递归中序遍历*/  
  66. {  
  67.     if (T==NULL)  
  68.         return;  
  69.     InOrderTraverse(T->lchild);  
  70.     std::cout<<T->data<<"\t";  
  71.     InOrderTraverse(T->rchild);  
  72. }  
  73.   
  74. void nInOrderTraverse(BiTNode *T)   /*非递归中序遍历*/  
  75. {  
  76.     if(T==NULL)  
  77.         return;  
  78.     std::stack<BiTNode*> stk;  
  79.     BiTNode* p;  
  80.     p = T;  
  81.     while(p!=NULL || !stk.empty())  
  82.     {  
  83.         while(p!=NULL)  
  84.         {  
  85.             stk.push(p);  
  86.             p = p->lchild;  
  87.         }  
  88.         if(!stk.empty())  
  89.         {  
  90.             p = stk.top();  
  91.             stk.pop();  
  92.             std::cout<<p->data<<"\t";  
  93.             p = p->rchild;  
  94.         }  
  95.     }  
  96. }  
  97.   
  98. void PostOrderTraverse(BiTNode *T)  /*递归后序遍历*/  
  99. {  
  100.     if(T==NULL)  
  101.             return;  
  102.     PostOrderTraverse(T->lchild);  
  103.     PostOrderTraverse(T->rchild);  
  104.     std::cout<<T->data<<"\t";  
  105. }  
  106.   
  107. void nPostOrderTraverse(BiTNode *T)     /*非递归后序遍历*/  
  108. {  
  109.     if(T==NULL)  
  110.         return;  
  111.     BiTNode* cur;       /*当前结点*/  
  112.     BiTNode* pre = NULL;        /*前一次输出的结点*/  
  113.     std::stack<BiTNode*> stk;  
  114.     stk.push(T);  
  115.     while(!stk.empty())  
  116.     {  
  117.         cur = stk.top();  
  118.         if((cur->lchild==NULL && cur->rchild==NULL) ||  
  119.             (pre!=NULL && (cur->lchild==pre || cur->rchild==pre)))      
  120.         {                               /*如果当前结点没有孩子结点或者孩子节点都已被访问过*/  
  121.             std::cout<<cur->data<<"\t";  
  122.             stk.pop();  
  123.             pre = cur;  
  124.         }  
  125.         else  
  126.         {  
  127.             if(cur->rchild!=NULL)  
  128.                 stk.push(cur->rchild);  
  129.             if(cur->lchild!=NULL)  
  130.                 stk.push(cur->lchild);  
  131.         }  
  132.     }  
  133. }  

2)main文件

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include"BiTree.h"  
  2. using namespace std;  
  3. int main()  
  4. {  
  5.     BiTNode *T=new BiTNode;  
  6.     std::cout<<"请前序遍历输入各节点：";  
  7.     CreateBiTree(&T);  
  8.     cout<<"\n该树的前序遍历输出为："<<endl;  
  9.     PreOrderTraverse(T);  
  10.     cout<<endl;  
  11.     nPreOrderTraverse(T);  
  12.     cout<<"\n该树的中序遍历输出为："<<endl;  
  13.     InOrderTraverse(T);  
  14.     cout<<endl;  
  15.     nInOrderTraverse(T);  
  16.     cout<<"\n该树的后序遍历输出为："<<endl;  
  17.     PostOrderTraverse(T);  
  18.     cout<<endl;  
  19.     nPostOrderTraverse(T);  
  20.     cout<<endl;  
  21.     return 0;  
  22. }  

5、测试结果







最后，用表格罗列一下前序、中序和后续遍历编程实现的区别，以便加强记忆。

 

不同点

相同点

前序遍历

1）在最外侧左子节点压入栈中的同时，输出该子节点的值；

2）发现节点存在“右节点”时，需要将当前节点弹出；

第一步，以根节点为起始，将左右最外侧左子节点压入栈中；

第二步，从栈顶元素进行判别，看是否存在右子节点；

第三步，重复第一、第二步，知道栈中元素为空

中序遍历

1）在最外侧左子节点压入栈中的时候，并不进行节点输出；

2）发现节点存在“右节点”时，需要将当前节点弹出；

后序遍历

1）在最外侧左子节点压入栈中的时候，并不进行节点输出；

2）发现节点存在“右节点”时，不需要弹出当前节点；

【注意】：第二次遍历到“既含有左节点又含有右节点”的根节点时，需要弹出该节点。因此需要利用两个堆栈来记录重复遍历的节点。

dcj0913
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的非递归遍历实现
zhangbaoanhadoop的博客
04-06 331
import java.util.Stack; public class Iterator1 { //先序遍历 public void preIterator(BiTree root) { if(root == null) return; Stack&lt;BiTree&gt; stack = new Stack&lt;BiTree&gt;(); BiTre...
二叉树遍历之非递归算法
热门推荐
__七把刀__
07-22 3万+
在前一篇文章二叉树遍历递归算法对二叉树遍历的递归算法做了总结，这篇文章就来对二叉树遍历的非递归算法做个汇总。还是与上一篇文章一样的顺序，一一汇总先序、中序、后序以及层序遍历的非递归算法。 1、先序遍历（非递归算法） 先序遍历非递归访问，使用栈即可实现。先序遍历的非递归访问在所有的遍历中算是最简单的了。主要思想就是先将根结点压入栈，然后根结点出栈并访问根结点，而后依次将根结点的右孩子、左
遍历二叉树的各种操作（非递归遍历）
ProgramVAE的博客
08-18 367
点击这里
lintcode练习-66.67.68.二叉树的三种递归遍历和非递归遍历
云中寻雾的博客
07-06 197
  二叉树的先序， 中序， 后序遍历 都是属于深度优先遍历。       直接上代码： 先序遍历：     class TreeNode: def __init__(self, val): self.val = val self.left, self.right = None, None class Solution: &quot;&quot;&quot; ...
二叉树非递归遍历的通用解法
litexy
03-14 1020
最近在跟慕课网上《玩转算法面试》这门课，老师讲的很不错，其中有一节提到了用栈来模拟二叉树的前序，中序，后序遍历。 二叉树的遍历的递归解法很简单，但有时面试或做题时往往会要求写出非递归的形式，一般教科书上实现的前序，中序和后序遍历的非递归形式差别都比较大，特别是后序遍历，很难理解。那有没有一种通用的迭代解法能适于这三种遍历呢？下面介绍一下这种通用解法。 基本思想 先给出前序遍历的递归形式代码如下： ...
erchashubianli.rar_二叉树遍历
最新发布
09-24
在C++中实现前序遍历，通常采用递归的方法，代码如下： ```cpp void preOrder(Node* root) { if (root != NULL) { cout << root->data ; preOrder(root->left); preOrder(root->right); } } ``` 2. **中序...
二叉树实现-二叉树操作
11-27
在IT领域，二叉树是一种基础且重要的数据结构，它在计算机科学中有着广泛的应用，尤其是在算法设计和数据存储上。...在C++中实现这些操作需要对指针和内存管理有深入的理解，同时也需要熟悉递归和非递归算法的设计。
CSP-S模拟赛模拟题附答案
04-14
- **C++语言**：CSP-S竞赛通常采用C++作为主要的编程语言，因为它提供了高效的数据处理能力和丰富的库支持。 - 基础语法：变量声明、循环控制、条件判断等。 - 函数与递归：理解函数的作用域、参数传递机制及递归...
数据结构-------二叉树
06-20
在压缩包中的&quot;二叉树&quot;文件可能包含关于二叉树的理论介绍、实例分析、代码实现（可能是C++、Java、Python等编程语言）以及练习题目。通过深入学习这些内容，你可以更好地理解和掌握二叉树的概念及其应用，从而在实际...
栈实现的二叉树遍历
01-02
&quot;nRecurson&quot;这个文件名可能暗示了对于递归实现的一种反思，提示我们关注非递归方法，如栈，来解决二叉树遍历问题。 总之，理解并熟练掌握二叉树的栈实现遍历对于任何IT专业人员来说都是至关重要的。这种技术不仅有...
二叉树实验
04-29
void load_bitre_file(bitre &t,char ss[100]) //构建文件二叉树 { char bs[6];int x;FILE *ff; ff=fopen(ss,&quot;r&quot;); if(ff==NULL){ printf(&quot;\ncan't open file!\007&quot;); exit(1); } fscanf(ff,&quot;%s&quot;,bs); while(fgetc(ff)!='\n'); fscanf(ff,&quot;%d&quot;,&x); while (fgetc(ff)!='\n'); if(strcmp(bs,&quot;bitre&quot;)) printf(&quot;file error!\007&quot;); else if(x==1) t=NULL; else load(t,ff); fclose(ff); }
二叉树非递归实现先序、中序、后序遍历
hi_sir_destroy的博客
09-03 299
创建先序遍历序列二叉树 测试数据: ABC000DE0F00G00 (这是一个先序序列 ，0表示当前结点为空) #include<stdio.h> #include<malloc.h> typedef struct node { char data; struct node *lchild; struct node *rchild; } node; ch...
用c语言编译二叉树,用C语言实现二叉树的结构和常用操作
weixin_28077113的博客
05-19 140
#include typedef float ElemType;typedef struct S_BiTNode//定义结点类型结构体{ElemType data;//数据域struct S_BiTNode * lchild;//左子树struct S_BiTNode * rchild;//右子树struct S_BiTNode * parent;//父结点}BiTNode;/**********...
数据结构 树
Cloud_yan的博客
10-27 314
基本导入 #include<stdio.h> #include<stdlib.h> #define MAX_TREE_SIZE 100 #define TelemType int #define Status int #define OK 1 #define ERROR 0 #define ElemType int 二叉树的存储结构 顺序存储 typedef TelemT...
std::stack使用总结
大山喵写博客的地方
01-07 5026
Stack（堆栈） 　　stack是一种简单而常用的数据结构，stl库中提供了现成的实现方案。 　　在使用stack的时候，需要包含头文件stack，其在std中的定义如下： template&amp;amp;lt; class T, class Container = std::deque&amp;amp;lt;T&amp;amp;gt; &amp;amp;gt; class stack; 　　第一个参数定义了元素的类型，第二个参数表示s...
非递归遍历二叉树实现
非典型程序员
09-12 1246
注意事项： 先序非递归算法的思想：1.二叉树指针不为空时，根指针入栈，指针指向左孩子，并将根结点输出。如果二叉树指针为空，根指针出栈，指针指向右孩子。（每一次出栈后指针指向其右孩子，可以保证每一个左右结点都可以遍历到） 后序遍历非递归算法：从根结点开始，将所有最左结点全部压栈，每当一个结点出栈时，都先扫描该结点的右子树，只有当一个结点的左孩子和右孩子结点均被访问过了，才能访问结点自身。 后序遍历...
二叉树的非递归遍历
我的梦
07-11 3025
本文全部参考自：https://blog.csdn.net/gogogo_sky/article/details/70145550 特别感谢，大家一起学习吧。 在我们了解了最简单的递归遍历以后，现在来说说用栈辅助，非递归实现二叉树的前序，中序，后序遍历打印 一、非递归实现前序遍历打印 前序遍历，访问的顺序为根-&gt;左-&gt;右； 前序遍历的思想： （1）首先定义...
二叉树遍历--递归实现
tubaluer
11-15 117
递归这东西真是抽象，我看着看着算法，就囫囵吞枣地的写了下，写得囧了··· 这次先用递归实现先序，中序，后序遍历算法。先大概说下原理：我输入一大串字符，中间#就是代表了空，基本的储存结构就是二叉链表。主要就是二叉树的创建和三种顺序的遍历。二叉树的创建通过从左孩子开始创建不断递归，知道读取了#，开始创建对应的右孩子，继续递归。访问的时候对于三种顺序不过就是对于操作的顺序改变而已。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值