二叉树的非递归遍历及算法分析

最新推荐文章于 2020-07-25 10:28:52 发布
最新推荐文章于 2020-07-25 10:28:52 发布
阅读量2.4k 收藏 17
点赞数 6
文章标签： 二叉树 非递归遍历 算法 c语言 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012914709/article/details/44498801
版权


二叉树介绍

二叉树是一类重要的数据结构。二叉树常被用于实现二叉查找树和二叉堆。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。

一种二叉树结点定义：

struct bit_node
{
	char data;
	struct bit_node *lchild,*rchild;
};

遍历是对树的一种最基本的运算，所谓遍历二叉树，就是按一定的规则和顺序走遍二叉树的所有结点，使每一个结点都被访问一次，而且只被访问一次。由于二叉树是非线性结构，因此，树的遍历实质上是将二叉树的各个结点转换成为一个线性序列来表示。

设L、D、R分别表示遍历左子树、访问根结点和遍历右子树，则对一棵二叉树的遍历有三种情况：DLR（称为先根次序遍历），LDR（称为中根次序遍历），LRD （称为后根次序遍历）。

 

递归方法遍历：

二叉树本身是一种递归定义的数据结构，所以递归遍历的方法是简单明了的方法。

DLR（先根次序遍历）

void traverse_bitree_dlr(struct bit_node *node)
{
	if(node != NULL)
	{
		printf("%3c", node->data);
		traverse_bitree_dlr(node->lchild);
		traverse_bitree_dlr(node->rchild);
	}
}

LDR（中根次序遍历）

void traverse_bitree_ldr(struct bit_node *node)
{
	if(node != NULL)
	{
		traverse_bitree_ldr(node->lchild);
		printf("%3c", node->data);
		traverse_bitree_ldr(node->rchild);
	}
}

LRD（后根次序遍历）

void traverse_bitree_lrd(struct bit_node *node)
{
	if(node != NULL)
	{
		traverse_bitree_lrd(node->lchild);
		traverse_bitree_lrd(node->rchild);
		printf("%3c", node->data);
	}
}

使用递归遍历的优点是算法简单明了，缺点也十分明显：对于栈的消耗比较大。尤其是在嵌入式应用中，嵌入式处理器资源往往有限。每次递归调用，都会涉及到通用寄存器、SP指针、PC指针等的压栈。当树的深度比较大时，对于栈的消耗会变得非常严重，很有可能造成栈的溢出。

 

非递归方法遍历：

因此，二叉树的非递归遍历方法就显得非常有实际应用价值。下面是非递归遍历的算法，这里使用了数据结构栈，利用其先进后出的特点，用结点入栈出栈过程手工模拟递归调用过程中的栈操作。

前序遍历

思想：使用数据结构栈，1保存结点左侧分支上的所有结点，并遍历结点；2出站时，切换至右子树；3重复1、2。

void traverse_bitree_dlr_nr(struct bit_node *root)
{
	struct bit_node *p;
	struct bit_node *stack[100];
	int i = -1;
	p = root;
	while(p != NULL || i != -1)
	{
		/*从当前结点开始搜索左子树，直至为空，并将分支上的左子树入栈*/
		while(p != NULL)
		{
			printf("%3c", p->data);	/*先入根结点再入左子树，入栈前遍历，前序*/
			stack[++i] = p;
			p = p->lchild;
		}
		if(i != -1)
		{
			p = stack[i--];			/*取出栈顶结点*/
			p = p->rchild;			/*切换至右子树*/
		}
	}
}

中序遍历

思想：使用数据结构栈，1保存结点左侧分支上的所有结点；2出站时遍历结点，切换至右子树；3重复1、2。

相对于前序遍历，中序遍历要求只是将左子树和根结点的顺序对调了一下，这不正符合栈的特点吗？！后进先出本身就是一个顺序反转过程。入栈时遍历，就是前序，出栈时遍历不就是中序遍历吗？！

void traverse_bitree_ldr_nr(struct bit_node *root)
{
	struct bit_node *p;
	struct bit_node *stack[100];
	int i = -1;
	p = root;
	while(p != NULL || i != -1)
	{
		/*从当前结点开始搜索左子树，直至为空，并将分支上的左子树入栈*/
		while(p != NULL)
		{
			stack[++i] = p;
			p = p->lchild;
		}
		if(i != -1)
		{
			p = stack[i--];			/*取出栈顶结点*/
			printf("%3c", p->data);	/*先出左子树，再出根结点，出栈后遍历，中序*/
			p = p->rchild;			/*切换至右子树*/
		}
	}
}

后序遍历

后序遍历是三种遍历中最复杂的。

第一种思想：

和前序、中序思想一样，使用栈手工模拟递归调用过程中栈操作过程。

后序遍历要求根结点在左右子树均遍历完成后才能遍历，更确切的条件就是，根结点要在其右子树遍历完成后紧接着遍历。这样就需要保存上一次遍历的结点信息。再者，栈中保存了未遍历的树的全部信息。后序遍历要求：先左子树，再右子树最后根结点，所以在右子树没有遍历完之前，根结点不能出栈。这一点其实也是递归后序遍历中所存在的过程。在具体代码中，相对于前序和中序又存在一个：右子树没有遍历时，结点需再次入栈的过程

出栈时如果满足为叶子节点，或者该结点的右孩子已经遍历，则遍历。

具体代码如下：

void traverse_bitree_lrd_nr(struct bit_node *root)
{
	struct bit_node *cur, *pre;
	struct bit_node *stack[100];
	int i = -1;
	cur = root;
	pre = NULL;
	while(cur != NULL || i != -1)
	{
		/*从当前结点开始搜索左子树，直至为空，并将分支上的左子树入栈*/
		while(cur != NULL)
		{
			stack[++i] = cur;
			cur = cur->lchild;
		}
		if(i != -1)
		{
			cur = stack[i--];		/*取出栈顶结点*/
			if(cur->rchild == NULL)	/*当前结点不存在右子树*/
			{
				pre = cur;			/*记录本次遍历的结点*/
				printf("%3c", cur->data);
				cur = NULL;			/*该结点已经遍历，为下一次从栈中取数据做准备*/
			}
			else					/*当前结点存在右子树*/
			{
				if (cur->rchild == pre)	/*如果该结点的右子树已经遍历，则遍历该结点*/
				{
					pre = cur;		/*记录本次遍历的结点*/
					printf("%3c", cur->data);
					cur = NULL;		/*该结点已经遍历，为下一次从栈中取数据做准备*/
				}
				else				/*如果该结点的右子树没有遍历，则结点入栈，并切换至右子树*/
				{
					stack[++i] = cur;
					cur = cur->rchild;
				}
			}
		}
	}
}

第二种思想：

完全利用栈的先进后出的特点，对于任意结点，先入栈右子树，再入栈左子树。出栈时如果满足为叶子节点，该结点的左孩子（只有左孩子）刚刚遍历过或者右孩子刚刚遍历，则遍历。这样就保证了遍历时先左子树，再右子树，最后根结点的顺序。

void traverse_bitree_lrd_nr_second(struct bit_node *root)
{
	struct bit_node *cur, *pre = NULL;
	struct bit_node *stack[100];
	int i = -1;
	stack[++i] = root;
	while (i != -1)
	{
		cur = stack[i];
		if ((cur->lchild == NULL && cur->rchild == NULL) || (pre != NULL && (pre == cur->lchild || pre == cur->rchild)))
		{
			printf("%3c", cur->data);
			i--;
			pre = cur;
		}
		else
		{
			if (cur->rchild != NULL)
			{
				stack[++i] = cur->rchild;
			}
			if (cur->lchild != NULL)
			{
				stack[++i] = cur->lchild;
			}
		}
	}
}

完整的测试源码

#include <stdio.h>
#include <stdlib.h>
struct bit_node
{
	char data;
	struct bit_node *lchild,*rchild;
};
void create_bitree_dlr(struct bit_node **root);
void traverse_bitree_dlr(struct bit_node *root);
void traverse_bitree_ldr(struct bit_node *root);
void traverse_bitree_lrd(struct bit_node *root);
void traverse_bitree_dlr_nr(struct bit_node *root);
void traverse_bitree_ldr_nr(struct bit_node *root);
void traverse_bitree_lrd_nr(struct bit_node *root);
void traverse_bitree_lrd_nr_second(struct bit_node *root);
void main(void)
{
	struct bit_node *root;
	/*crate binary tree in pre order*/
	create_bitree_dlr(&root);
	printf("\ncreate bitree successfully!\n");

	/*pre order traversing with recurse method*/
	traverse_bitree_dlr(root);
	printf("\ndlr recurse traverse bitress successfully!\n");

	/*in order traversing with recurse method*/
	traverse_bitree_ldr(root);
	printf("\nldr recurse traverse bitress successfully!\n");

	/*post order traversing with recurse method*/
	traverse_bitree_lrd(root);
	printf("\nlrd recurse traverse bitress successfully!\n");

	/*pre order traversing with stack method*/
	traverse_bitree_dlr_nr(root);
	printf("\ndlr no recurse traverse bitress successfully!\n");

	/*in order traversing with stack method*/
	traverse_bitree_ldr_nr(root);
	printf("\nldr no recurse traverse bitress successfully!\n");

	/*post order traversing with stack method*/
	traverse_bitree_lrd_nr(root);
	printf("\nlrd no recurse traverse bitress successfully!\n");

	/*second post order traversing with stack method*/
	traverse_bitree_lrd_nr_second(root);
	printf("\nsecond lrd no recurse traverse bitress successfully!\n");
}
void create_bitree_dlr(struct bit_node **node)
{
	char data;
	data = getchar();
	getchar();
	if(data != 'p')
	{
		*node = (struct bit_node *)malloc(sizeof(struct bit_node));
		(*node)->data = data;
		create_bitree_dlr(&((*node)->lchild));
		create_bitree_dlr(&((*node)->rchild));
	}
	else
	{
		*node = NULL;
	}
}
void traverse_bitree_dlr(struct bit_node *node)
{
	if(node != NULL)
	{
		printf("%3c", node->data);
		traverse_bitree_dlr(node->lchild);
		traverse_bitree_dlr(node->rchild);
	}
}
void traverse_bitree_ldr(struct bit_node *node)
{
	if(node != NULL)
	{
		traverse_bitree_ldr(node->lchild);
		printf("%3c", node->data);
		traverse_bitree_ldr(node->rchild);
	}
}
void traverse_bitree_lrd(struct bit_node *node)
{
	if(node != NULL)
	{
		traverse_bitree_lrd(node->lchild);
		traverse_bitree_lrd(node->rchild);
		printf("%3c", node->data);
	}
}
void traverse_bitree_dlr_nr(struct bit_node *root)
{
	struct bit_node *p;
	struct bit_node *stack[100];
	int i = -1;
	p = root;
	while(p != NULL || i != -1)
	{
		/*从当前结点开始搜索左子树，直至为空，并将分支上的左子树入栈*/
		while(p != NULL)
		{
			printf("%3c", p->data);	/*先入根结点再入左子树，入栈前遍历，前序*/
			stack[++i] = p;
			p = p->lchild;
		}
		if(i != -1)
		{
			p = stack[i--];			/*取出栈顶结点*/
			p = p->rchild;			/*切换至右子树*/
		}
	}
}
void traverse_bitree_ldr_nr(struct bit_node *root)
{
	struct bit_node *p;
	struct bit_node *stack[100];
	int i = -1;
	p = root;
	while(p != NULL || i != -1)
	{
		/*从当前结点开始搜索左子树，直至为空，并将分支上的左子树入栈*/
		while(p != NULL)
		{
			stack[++i] = p;
			p = p->lchild;
		}
		if(i != -1)
		{
			p = stack[i--];			/*取出栈顶结点*/
			printf("%3c", p->data);	/*先出左子树，再出根结点，出栈后遍历，中序*/
			p = p->rchild;			/*切换至右子树*/
		}
	}
}
void traverse_bitree_lrd_nr(struct bit_node *root)
{
	struct bit_node *cur, *pre;
	struct bit_node *stack[100];
	int i = -1;
	cur = root;
	pre = NULL;
	while(cur != NULL || i != -1)
	{
		/*从当前结点开始搜索左子树，直至为空，并将分支上的左子树入栈*/
		while(cur != NULL)
		{
			stack[++i] = cur;
			cur = cur->lchild;
		}
		if(i != -1)
		{
			cur = stack[i--];		/*取出栈顶结点*/
			if(cur->rchild == NULL)	/*当前结点不存在右子树*/
			{
				pre = cur;			/*记录本次遍历的结点*/
				printf("%3c", cur->data);
				cur = NULL;			/*该结点已经遍历，为下一次从栈中取数据做准备*/
			}
			else					/*当前结点存在右子树*/
			{
				if (cur->rchild == pre)	/*如果该结点的右子树已经遍历，则遍历该结点*/
				{
					pre = cur;		/*记录本次遍历的结点*/
					printf("%3c", cur->data);
					cur = NULL;		/*该结点已经遍历，为下一次从栈中取数据做准备*/
				}
				else				/*如果该结点的右子树没有遍历，则结点入栈，并切换至右子树*/
				{
					stack[++i] = cur;
					cur = cur->rchild;
				}
			}
		}
	}
}
void traverse_bitree_lrd_nr_second(struct bit_node *root)
{
	struct bit_node *cur, *pre = NULL;
	struct bit_node *stack[100];
	int i = -1;
	stack[++i] = root;
	while (i != -1)
	{
		cur = stack[i];
		if ((cur->lchild == NULL && cur->rchild == NULL) || (pre != NULL && (pre == cur->lchild || pre == cur->rchild)))
		{
			printf("%3c", cur->data);
			i--;
			pre = cur;
		}
		else
		{
			if (cur->rchild != NULL)
			{
				stack[++i] = cur->rchild;
			}
			if (cur->lchild != NULL)
			{
				stack[++i] = cur->lchild;
			}
		}
	}
}

测试数据：

abdppeppcfppp

输出：

create bitree successfully!

 a  b  d e  c  f

dlr recurse traverse bitress successfully!

 d  b  e a  f  c

ldr recurse traverse bitress successfully!

 d  e  b f  c  a

lrd recurse traverse bitress successfully!

 a  b  d e  c  f

dlr no recurse traverse bitresssuccessfully!

 d  b  e a  f  c

ldr no recurse traverse bitresssuccessfully!

 d  e  b f  c  a

lrd no recurse traverse bitresssuccessfully!

 d  e  b f  c  a

second lrd no recurse traverse bitresssuccessfully!




                

        

        

    

  


    

      

        

            

              
                
                  周子plus
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
二叉树非递归遍历算法分析

				
			

			

				

					weixin_43875867的博客
				

				

					05-08
					
					1105
					
				

			

		

		

			
				
本文介绍了二叉树非递归遍历算法的一种实现方式，以及这种遍历算法是怎么推导出来的。

			
		

	



                

              
                



	

		

			

				
					
二叉树的非递归遍历算法

				
			

			

				

					02-28
				

			

		

		

			
				
⒈ 二叉树的中序、前序、后序的递归、非递归遍历算法，层次序的非递归遍历算法的实现；
⒉ 树与二叉树的转换的实现。

			
		

	



                


  
              

                


	

		

			

				
					
精典二叉树非递归遍历的算法

				
			

			

				

					benzs的专栏
				

				

					09-22
					
					1898
					
				

			

		

		

			
				
遍历二叉树的非递归算法编写的方法：根据树中结点的遍历规律及顺序直接写出其非递归算法。先序非递归算法【思路】假设：T是要遍历树的根指针，若T != NULL对于非递归算法，引入栈模拟递归工作栈，初始时栈为空。问题：如何用栈来保存信息，使得在先序遍历过左子树后，能利用栈顶信息获取T的右子树的根指针？方法1：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历

			
		

	





	

		

			

				
					
遍历二叉树的非递归算法

				
			

			

				

					 Learn as if you were to live forever
				

				

					01-30
					
					866
					
				

			

		

		

			
				
三种次序的寻访路线，它是从根结点开始沿左子树深入直到最左下端时，返回进入刚刚遇到结点的右子树；在右子树中，也是先深入到它的最左下结点时返回刚遇到结点的右子树······如此深入和返回，直到从根结点的右子树返回根结点止。在这一过程中，返回结点的顺序恰与深入结点的顺序相反，先深入的后返回，正好符合栈的特点。所以可以用栈来保存遍历过程中的结点信息来实现遍历二叉树的非递归算法，并且假定栈空间足够大不会发生

			
		

	



		

			
		



	

		

			

				
					
递归非递归实现树的遍历

				
			

			

				

					cxh342968816的专栏
				

				

					08-05
					
					856
					
				

			

		

		

			
				
1.先序遍历
从递归说起


void preOrder(TNode* root){    if (root != NULL)    {        Visit(root);        preOrder(root->left);        preOrder(ro

			
		

	





	

		

			

				
					
C语言二叉树的非递归遍历实例分析

				
			

			

				

					09-04
				

			

		

		

			
				
本文主要关注非递归遍历方法。  **先序遍历**： 先序遍历的顺序是：根节点 -> 左子树 -> 右子树。在非递归实现中，我们使用一个栈来辅助遍历。首先将根节点压入栈，然后进入一个循环，直到栈为空。在循环中，每次弹...

			
		

	





	

		

			

				
					
二叉树非递归遍历程序

				
			

			

				

					07-03
				

			

		

		

			
				
在本篇文档中，作者分享了一个基于链表实现的二叉树非递归遍历算法，具体实现了前序遍历。这种遍历方法不使用递归调用，而是通过循环和辅助栈来完成遍历过程，有助于节省内存资源并提高执行效率。  ### 二叉树的基本...

			
		

	





	

		

			

				
					
数据结构与算法分析 二叉树的遍历

				
			

			

				

					chenning2015的博客
				

				

					05-08
					
					244
					
				

			

		

		

			
				
数据结构与算法分析 二叉树的遍历
树的三种遍历，递归+非递归。深度优先，广度优先遍历二叉树

树的遍历（先中后）
递归版本
package cn.ustb.树的遍历;
//递归遍历
public class MyBinaryTree {
	static class Node{
		Node l...

			
		

	





	

		

			

				
					
二叉树非递归遍历算法详解

				
			

			

				

					QiaoRuoZhuo的专栏
				

				

					09-20
					
					1348
					
				

			

		

		

			
				
二叉树的递归算法很容易实现，而且简明易懂，但非递归算法就不是那么好理解了。本文将结合代码详细解释遍历二叉树的三种不同方式。

			
		

	





	

		

			

				
					
二叉树遍历的非递归算法

				
			

			

				

					wuruiaoxue的专栏
				

				

					07-03
					
					1152
					
				

			

		

		

			
				
所谓二叉树的遍历，就是按照某种次序访问二叉树中每个节点，而且每个节点仅访问一次的过程。以L,N,R分别表示遍历左子树、访问根节点和遍历右子树，则可能有NLR、LNR、LRN、NRL、RNL、RLN等六种遍历方式。若限定先左后右，则只有前三种遍历，分别称为先序遍历、中序遍历、后序遍历，另外还有一种层序的遍历方式。
由于遍历的递归算法比较简单，这里只介绍遍历的非递归算法。这里给二叉链存储结构中节点类

			
		

	





	

		

			

				
					
二叉树遍历非递归算法

				
			

			

				

					MJ_Lee的博客
				

				

					07-16
					
					569
					
				

			

		

		

			
				
1.结构体：
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
 };
typedef struct TreeNode* Tree;

typedef struct{
    Tree* array;
    int top;
}Stack;

2.二叉树的前序遍历(Preorder Trave...

			
		

	





	

		

			

				
					
二叉树—遍历非递归算法

				
			

			

				

					Dengzwwwwww的博客
				

				

					07-25
					
					434
					
				

			

		

		

			
				
#include <iostream>
#include <stack>
using namespace std;
typedef  struct  TreeNode* BinTree;
//typedef  BinTree Position; 
struct  TreeNode {
    char  Data;
    BinTree  Left;
    BinTree  Right;
};
/*以前序遍历的形式输入来创建树*/
void CreatBinTree(Bin...

			
		

	





	

		

			

				
					
二叉树非递归遍历算法实现及流程图解析

				
			

			

				

					
				

			

		

		

			
				
"二叉树非递归遍历的实现"  在数据结构中，二叉树是一种基础且重要的数据结构，它可以用来表示多种问题的结构。本资源详细介绍了如何实现二叉树的非递归遍历算法，这是一种避免使用递归方法来遍历二叉树的策略。递归...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值