数据结构和算法 递归/循环遍历二叉树

最新推荐文章于 2024-03-18 22:37:00 发布
最新推荐文章于 2024-03-18 22:37:00 发布
阅读量751 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 开发语言 文章标签： 数据结构 散列表 二叉树 循环遍历二叉树 递归遍历二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bashendixie5/article/details/124481366
本文介绍了二叉树的基本概念及其五种形态，并通过C++代码展示了递归和循环遍历二叉树的方法。递归遍历简洁但效率受节点数量影响，循环遍历利用栈结构避免了这个问题。代码示例中，二叉树的节点包含数据，并实现了添加、遍历和销毁功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、二叉树概述

        二叉树是一种常见的数据结构，其特点是每一个节点元素都最多包含两个子节点，左子节点和右子节点。

        二叉树可以有5种基本形态，空二叉树、只有根节点、右子树为空，左子树为空，左、右子树均非空。

        二叉树有着广泛的应用，如描述语法结构，表示数据库对象的层次关系。

2、递归遍历二叉树

        下面c++代码定义了二叉树类模板和节点类型，然后使用递归方法进行二叉树遍历。递归遍历的缺点是如果二叉树的节点较多，系统性能会收到很大影响。

#include "stdafx.h"
#include <iostream.h>
#include <memory.h>

template <class  Type>						//定义二叉树类模板
class CBinaryTree
{
private:
	int		m_nNodeCount;				//节点数量
	Type*	m_pRootNode;					//根节点
public:
	CBinaryTree()							//构造函数
	{
		m_pRootNode = new Type();			//构建根节点
		m_nNodeCount = 1;					//设置节点数量
		InitBinaryTree();					//初始化二叉树
	}	
	Type* GetRootNode() const				//获取根节点
	{
		return m_pRootNode;
	}
	void InitBinaryTree()						//初始化二叉树
	{
		Type* pTmpNode = m_pRootNode;
		for(int i=1; i< 11; i++)					//添加10个节点
		{
			Type* pNode = new Type;
			pNode->m_nData = i;
label:		bool bRet = AddNode(pTmpNode, pNode, 0);	//添加左节点
			if (!bRet)								//添加失败，则添加右节点
			{
				bRet = AddNode(pTmpNode, pNode, 1);
			}
			if (!bRet)										//该节点左右节点都存在
			{
				pTmpNode = pTmpNode->m_pLeftNode;
				goto label;
			}
		}
	} 
	
	void IterateBinaryTree(Type *pNode)						//递归遍历二叉树
	{
		if (pNode != NULL)									//如果节点不为空
		{
			cout << "节点数据: " << pNode->m_nData << endl;		//输出节点数据
		}
		if (pNode->m_pLeftNode != NULL)						//如果左节点不为空
		{
			IterateBinaryTree(pNode->m_pLeftNode);				//递归调用
		}
		if (pNode->m_pRightNode != NULL)						//如果右节点不为空
		{
			IterateBinaryTree(pNode->m_pRightNode);			//递归调用
		}
	}
	bool AddNode(Type *pDestation, Type *pNode, int nFlag = 0)		//在为节点添加数据
	{
		if (pDestation != NULL && pNode != NULL)
		{
			if (nFlag)										//添加右节点
			{
				if (!pDestation->m_pRightNode)
				{
					pDestation->m_pRightNode = pNode;
				}
				else										//pDestation已经有了右节点
				{
					return false;
				}
			}
			else											//添加左节点
			{
				if (!pDestation->m_pLeftNode)
				{
					pDestation->m_pLeftNode = pNode;
				}
				else										//pDestation已经有了右节点
				{
					return false;
				}
			}
			m_nNodeCount++;
			return true;
		}
		return false;
	}
	
	void DestroyBinaryTree(Type *pNode)						//释放二叉树节点
	{
		Type *pLeftNode, *pRightNode;
		if (pNode != NULL)									//如果节点不为空
		{
			pLeftNode = pNode->m_pLeftNode;					//记录左子节点
			pRightNode = pNode->m_pRightNode;				//记录右子节点
			delete pNode;									//释放当前节点
			pNode = NULL;
		}
		if (pLeftNode != NULL)								//如果左子节点不为空
		{
			DestroyBinaryTree(pLeftNode);
		}	
		if (pRightNode != NULL)								//如果右子节点不为空
		{
			DestroyBinaryTree(pRightNode);
		}
	}
	virtual ~CBinaryTree()									//析构函数
	{
		DestroyBinaryTree(m_pRootNode);						//释放二叉树节点
	}
};

class CNode												//定义节点类型
{
private:
	CNode	*m_pLeftNode;									//左子节点
	CNode	*m_pRightNode;								//右子节点
	int		m_nData;										//节点数据
public:
	CNode()												//默认构造函数	
	{
		m_pLeftNode		= NULL;
		m_pRightNode	= NULL;
		m_nData			= 0;
	}
	friend class CBinaryTree<CNode>;						//将CBinary声明为友元类
	virtual ~CNode()
	{
		m_pLeftNode		= NULL;
		m_pRightNode	= NULL;
		m_nData			= 0;		
	}
};



int main(int argc, char* argv[])
{
	CBinaryTree<CNode> BinaryTree;							//定义二叉树对象
	BinaryTree.IterateBinaryTree(BinaryTree.GetRootNode());		//递归遍历二叉树
	return 0;
}

3、循环遍历二叉树

        利用循环遍历二叉树，需要设计栈的结构，用于存储遍历的节点，利用栈结构的后进先出的特点，遍历所有节点。主要思路是首先根据根节点遍历其下左节点，直至左子节点为空。

 

#include "stdafx.h"
#include <iostream.h>
#include <memory.h>


//设计一个栈结构
template <class Type>
class  CStact
{
private:
	Type *m_pBottom;	//栈底
	Type *m_pTop;		//栈顶
	int				m_nStackSize;			//栈大小，单位是1个元素
public:
	CStact()
	{
		m_pBottom = NULL;
		m_pTop = NULL;
		m_nStackSize = 30;
	}
	~CStact()								//析构函数						
	{
		  if (m_pBottom != NULL)
		  {
				m_pBottom ++;
				delete [] m_pBottom;
		  }
	}
	bool InitStack(int nStackSize)			//初始化栈
	{
		m_nStackSize = nStackSize;
		try
		{
			m_pBottom = new Type[m_nStackSize];
			m_pBottom--;					//落入栈底
			m_pTop = m_pBottom;				//空栈
		}
		catch(...)
		{
			return false;					//初始化失败
		}
		return true;
	}
	bool Push(Type *pNode)		//入栈
	{
		if (m_pTop - m_pBottom >= m_nStackSize || pNode == NULL)
		{
			return false;					//栈溢出
		}
		m_pTop++;							//移动栈顶指针
		memcpy(m_pTop, pNode, sizeof(Type));
		return true;
	}
	bool Pop(Type *pNode)			//出栈
	{
		if (m_pTop == m_pBottom)				//空栈
		{
			return false;
		}
		memcpy(pNode, m_pTop, sizeof(Type));
		m_pTop--;
		return true;
	}
	bool GetTop(Type *pNode)		//获取栈顶数据
	{
		if (m_Top == m_pBottom)				//空栈
		{
			return false;
		}
		memcpy(pNode, m_pTop, sizeof(Type));
		return true;
	}
	bool IsEmpty()							//是否为空栈
	{
		return (m_pTop == m_pBottom);
	}
};


//定义二叉树
template <class  Type>
class CBinaryTree
{
private:
	int		m_nNodeCount;			//节点数量
	Type*	m_pRootNode;			//根节点
public:
	CBinaryTree()					//构造函数
	{
		m_pRootNode = new Type();
		m_nNodeCount = 1;
		InitBinaryTree();
	}

	void InitBinaryTree()				//初始化二叉树
	{
		Type* pTmpNode = m_pRootNode;
		for(int i=1; i< 11; i++)		//添加10个节点
		{
			Type* pNode = new Type;
			pNode->m_nData = i;
label:		bool bRet = AddNode(pTmpNode, pNode, 0);	//添加左节点
			if (!bRet)									//添加失败，则添加右节点
			{
				bRet = AddNode(pTmpNode, pNode, 1);
			}
			if (!bRet)									//该节点左右节点都存在
			{
				pTmpNode = pTmpNode->m_pLeftNode;
				goto label;
			}
		}
	} 

	void LoopBinaryTree()					//循环遍历二叉树
	{
		CStact<CNode> Stack;							//定义一个栈
		Stack.InitStack(m_nNodeCount);					//初始化栈
		Stack.Push(m_pRootNode);						//将根节点入栈
		Type *pNode = m_pRootNode;
		while(!Stack.IsEmpty())
		{
			if (pNode)
			{
				while(pNode)								//遍历左子节点，直到尽头
				{
					Stack.Push(pNode->m_pLeftNode);			//入栈
					pNode = pNode->m_pLeftNode;
				}
			}
			else
			{
				Type Node;
				bool bRet = Stack.Pop(&Node);							//回退指针	
				if (bRet)
				{
					cout << "节点数据: " << Node.m_nData << endl;
				}
				bRet = Stack.Pop(&Node);
				if (bRet)
				{
					cout << "节点数据: " << Node.m_nData << endl;
				}
				if (bRet && Node.m_pRightNode != NULL)
				{
					Stack.Push(Node.m_pRightNode);
					pNode = Node.m_pRightNode;
				}				
			}
		}
	}

	bool AddNode(Type *pDestation, Type *pNode, int nFlag = 0)		//在为节点添加数据
	{
		if (pDestation != NULL && pNode != NULL)
		{
			if (nFlag)				//添加右节点
			{
				if (!pDestation->m_pRightNode)
				{
					pDestation->m_pRightNode = pNode;
				}
				else				//pDestation已经有了右节点
				{
					return false;
				}
			}
			else					//添加左节点
			{
				if (!pDestation->m_pLeftNode)
				{
					pDestation->m_pLeftNode = pNode;
				}
				else				//pDestation已经有了右节点
				{
					return false;
				}				
			}
			m_nNodeCount++;
			return true;
		}
		return false;
	}
	
	void DestroyBinaryTree(Type *pNode)		//释放二叉树节点
	{
		Type *pLeftNode, *pRightNode;
		if (pNode != NULL)
		{
			pLeftNode = pNode->m_pLeftNode;
			pRightNode = pNode->m_pRightNode;
			delete pNode;
			pNode = NULL;
		}
		if (pLeftNode != NULL)
		{
			DestroyBinaryTree(pLeftNode);
		}
		if (pRightNode != NULL)
		{
			DestroyBinaryTree(pRightNode);
		}		
	}

	virtual ~CBinaryTree()			//析构函数
	{
		//释放二叉树节点
		DestroyBinaryTree(m_pRootNode);
	}
};


//定义节点类型
class CNode
{
private:
	CNode	*m_pLeftNode;	//左子节点
	CNode	*m_pRightNode;	//右子节点
	int		m_nData;		//节点数据
public:
	CNode()					//默认构造函数					
	{
		m_pLeftNode		= NULL;
		m_pRightNode	= NULL;
		m_nData			= 0;
	}
	friend class CBinaryTree<CNode>;
	virtual ~CNode()
	{
		m_pLeftNode		= NULL;
		m_pRightNode	= NULL;
		m_nData			= 0;		
	}
};


int main(int argc, char* argv[])
{
	CBinaryTree<CNode> BinaryTree;
	BinaryTree.LoopBinaryTree();
	return 0;
}

二叉树各种基本运算的算法
小宋的博客
11-22 3653
【代码】 #include #include #define MaxSize 100 typedef char ElemType; typedef struct node { ElemType data; //数据元素 struct node *lchild; //指向左孩子节点 struct node *rchild; //指向右孩子节点 } BTNode; void Cre
二叉树的基本操作(先序序列创建二叉树/先序遍历递归算法/中序遍历递归算法/后序遍历递归算法/求二叉树深度的递归算法)
weixin_42048463的博客
05-01 4777
二叉树的存储结构有顺序存储和链式存储两种存储方式，这里我们采用使用频率较高的链式存储方式(二叉链表)来存储二叉树. 下面给出二叉树结点的定义. struct BiTreeNode//二叉树结点定义 { BiTreeNode* LChild;//左孩子指针域 int data; BiTreeNode* RChild;//右孩子指针域 }; ...
循环遍历二叉树
12-29
运用c++控制台应用程序实现对二叉树的循环遍历
使用循环的方式遍历二叉树
yrc_Note的博客
09-26 3373
一、基本概念每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若其深度为h，则其所包含的结点数必为2^h-1。 完全二叉树：除了最大的层次即成为一颗满二叉树且层次最大那层所有的结点均向左靠齐，即集中在左面
数据结构-非递归遍历二叉树
11-16
总之，非递归遍历二叉树是数据结构中的重要概念，它涉及栈和队列等基本数据结构的操作，以及逻辑控制的巧妙运用。掌握这些技巧，不仅可以帮助我们更好地理解和应用二叉树，也有助于提升我们的算法设计能力。
数据结构 非递归实现中序遍历二叉树
aduanzz的博客
11-16 1173
参考书籍：c++ 数据结构 之前提到用递归的方法实现中序遍历二叉树，但是递归会浪费大量的空间与时间。这时候我们就在想用没有一种方式能够不依赖递归去实现遍历二叉树。我们之前学过一种数据结构可以实现这种方法，那就是链表。 话不多说，我们先上代码： //非递归遍历二叉树 void InOrderTraverse(Stack &S,BinTree& B) { InitStack(S); ...
【数据结构】二叉树的存储结构及先/中/后序递归遍历算法（C语言）
weixin_51450101的博客
02-03 4810
目录1. 树与二叉树1.1 树的基本概念1.2 二叉树的基本概念2. 二叉树的存储结构及遍历算法2.1 二叉树的存储结构2.2 二叉树的前中后序遍历2.3 遍历算法的应用2.4 完整实现代码2.5 运行结果3. 遍历算法基于栈的递归消除 1. 树与二叉树 1.1 树的基本概念 树是 n（n>=0）个结点的有限集合 T。当 n = 0 时，称为空树；当 n>0 时，该集合满足： ① 其中必有一个称为根（root）的特定结点，它没有直接前驱，但有零个或多个直接后驱。 ② 其余 n-1 个结点可以划分
C语言 中序遍历二叉树--非递归算法
qq_43402544的博客
10-22 4989
完整代码如下： #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct BiTNode//二叉树的结构体 { char ch;//二叉树的数据域 struct BiTNode *lchild,*rchild;//二叉树的指针域 }BiTNode ,*BiTree; typedef struct StackNode //栈的结构体 { BiTree data;//栈
二叉树遍历
chinaherolts2008的博客
03-07 148
前言 使用C#实现一个二叉树及其基本操作, 配合xunit来做单元测试; 所以数据结构的定义和算法均使用C#实现; 概念 二叉树或为空树, 或是由一个根结点加上两棵分别称为左子树和右子树的、互不交的二叉树组成; 二叉树的遍历 二叉树遍历的递归算法比较简洁, 思路比较清晰, 但是非递归的版本, 个人觉得有点难度, 我最开始看的北大一个课c#教程程中的二叉树的非递归算法, 思路很巧妙, 但是不是那么容易想到的, 后来我自己思考了一段时间, 实现了我自己版本的非递归遍历算法; 这里我用xunit做的单元测试来验
二叉树的循环遍历和递归遍历（经典）
隔壁老王呀的专栏
01-12 1077
主要介绍二叉树遍历的经典方法：递归和循环 递归遍历 前序遍历：根、左、右 中序遍历：左、跟、右 后序遍历：左、右、跟 循环遍历 前序遍历：跟、左、右 中序遍历：左、跟、右 后序遍历：左、右、跟
数据结构与算法之 二叉树 (一)递归算法
实践是检验真理的唯一标准
09-01 472
#include using namespace std; struct tree_node { int data; tree_node *lchild; tree_node *rchild; }; void create_btree(tree_node** b_tree) { int c = 0; cin>>c; if(c != 0) { *b_tree = new tre
二叉树-循环遍历
雯雯熊孩子
08-11 523
前序遍历的基本思想就是visit 当前node，push right node，当前node向左下移动。如果当前node是空，那么从stack弹出一个node，并把它当做一个崭新的root node，继续循环。 preOrder (Node node) {     Stack s = new Stack();     while (node != null || !s.isEmpty()) { i
数据结构笔记（十五）二叉树的遍历（循环）
2301_79268604的博客
03-18 774
NULL||isEmpty(&stack))//根结点为空并且栈清零结束。=NULL||isEmpty(&stack))//根结点为空并且栈清零结束。while(root)//根结点如果为空结束，此时栈为为空结点的父结点。while(root)//根结点如果为空结束，此时栈为为空结点的父结点。//找到最后入栈的结点。//找到最后入栈的结点。
二叉树的中序遍历（循环实现）
辉的博客
08-01 3948
二叉树用递归进行中序遍历是很容易实现的，但是如果能用循环实现的话效率会更好，本人刷题的时候发现了循环写法，故此做下笔记。 理论： 一般的中序遍历代码为： def bst(root): if not root: return else: bst(root.left) return root.val bst(root.right) 循环写法： def bst(root): stack = [] p = root res = [] while p or st
java实现循环遍历二叉树
qq_41738049的博客
06-18 940
import java.util.Stack; /** * 循环遍历二叉树 * @author * */ public class BinaryTree { public static class TreeNode { int val; TreeNode left; TreeNode right; public TreeNode (){} public TreeNode (...
循环实现二叉树的中序遍历
热门推荐
圆圆的汤圆的博客
06-02 1万+
01 二叉树的中序遍历回顾 中序遍历即父节点在中间遍历，遍历的顺序是左孩子，父节点，右孩子。对于整棵树来说，0是父节点，左边的树枝是左孩子节点，右边的树枝是右孩子节点。如下图所示。 遍历过程如下： 对于 0的整个左孩子树枝来说，又是一个父子结构， 3是左孩子节点，1是父节点，4是右孩子节点。他们的遍历顺序是3，1，4。 遍历父节点，0 对于0的整个右孩子树枝也类似。先...
先序非递归遍历算法遍历二叉树 ​中序非递归遍历算法遍历二叉树 ​后序非递归遍历算法遍历二叉树 ​层序遍历二叉树
最新发布
05-09
好的，我可以给您介绍一下二叉树的四种非递归遍历算法以及层序遍历。 先序非递归遍历算法： 1. 新建一个栈，将根节点入栈。 2. 当栈不为空时，取出栈顶元素并访问它。 3. 将当前节点的右子节点（如果存在）入栈，再将左子节点（如果存在）入栈。 4. 重复步骤2-3，直到栈为空。 中序非递归遍历算法： 1. 新建一个栈，将根节点入栈。 2. 如果当前节点不为空，则将当前节点的左子节点全部入栈，并将当前节点置为左子节点。 3. 如果当前节点为空，则取出栈顶元素并访问它，将当前节点置为它的右子节点。 4. 重复步骤2-3，直到栈为空。 后序非递归遍历算法： 1. 新建两个栈：s1和s2，将根节点入s1。 2. 当s1不为空时，取出栈顶元素并将其压入s2中。 3. 将当前节点的左子节点（如果存在）入s1，再将右子节点（如果存在）入s1。 4. 重复步骤2-3，直到s1为空。 5. 依次访问s2中的元素即可得到后序遍历结果。 层序遍历算法： 1. 新建一个队列，将根节点入队。 2. 当队列不为空时，取出队首元素并访问它。 3. 将当前节点的左子节点（如果存在）入队，再将右子节点（如果存在）入队。 4. 重复步骤2-3，直到队列为空。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

坐望云起

如果觉得有用，请不吝打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值