数据结构-二叉树[非递归遍历]（先序遍历，中序遍历，后续遍历，层次遍历）

最新推荐文章于 2020-12-09 17:08:48 发布
最新推荐文章于 2020-12-09 17:08:48 发布
阅读量541 收藏 5
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 二叉树 完全二叉树和满二叉树的非递归构造 二叉树的非递归遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SZU_Crayon/article/details/81041733
版权
本文详细介绍了二叉树的非递归遍历，包括先序、中序、后序和层次遍历。通过利用完全和满二叉树的特性，实现了非递归构造方法。在遍历部分，讲解了不同遍历方式的思路和代码实现，为理解二叉树的非递归操作提供了清晰的指导。
摘要由CSDN通过智能技术生成

数据结构-二叉树[非递归遍历]

1.二叉树概念

2.二叉树的构造及删除

    不得不说下二叉树的构造，本来我是想找非递归实现的，结果只看到了完全二叉树和满二叉树（下文有）的构造方法，所以这一部分我暂时函数用前序的方法构造和删除，然后二叉树的概念在上篇文：二叉树的递归实现有介绍所以放个传送门大家自己去看看。

    传送门:    点击打开链接

3.完全二叉树和满二叉树的非递归构造

    (1)思路：利用完全和满二叉树双亲节点与左右孩子节点编号的关系

                    ①双亲节点编号=左孩子或右孩子节点编号/2

                    ②孩子节点编号%2=1，该孩子节点是右孩子节点

                    ③孩子节点编号%2=0，该孩子节点是左孩子节点

         利用节点地址数组储存节点，并按照上述关系建立节点联系

（2）实现代码

template<class T>
int Binary_tree<T>::Create_BTree(Bt_Node<T>* &Tree)		//满二叉树和完全二叉树的创建方法（非递归）
{
	Bt_Node<T>* Bt_Node_List[MAXSIZE];		//创建节点指针数组
	//Bt_Node_List = new Bt_Node<T>*[MAXSIZE];
	Bt_Node<T>* Start_Node;
	T Data;
	int Index, FindParent;		//Index为树节点编号，FindParent是查找双亲节点的编号
	cin >> Index >> Data;		//输入树节点的编号及数据
	while (Index != 0 && Data != -1)		//编号不为0且输入数据为-1代表结束
	{
		Start_Node = new Bt_Node<T>;
		Start_Node->Data = Data;
		Start_Node->Left_Child = NULL;		//左孩子和右孩子节点先赋值空
		Start_Node->Right_Child = NULL;
		Bt_Node_List[Index] = Start_Node;
		if (Index != 1)		//当该节点不是根节点
		{
			FindParent = Index / 2;			//寻找该节点的双亲节点
			if (Index % 2)					//若该节点编号对2取余结果为1，说明该节点是其双亲节点的右孩子节点，否则为左孩子节点
				Bt_Node_List[FindParent]->Right_Child = Start_Node;			//双亲节点找到自己的孩子
			else
				Bt_Node_List[FindParent]->Left_Child = Start_Node;
		}
		cin >> Index >> Data;		//继续输入数据
	}
	Tree = Bt_Node_List[1];			//在节点地址数组的位置为1的节点为根节点
	return 1;

4.二叉树的非递归遍历（正文开始）

    非递归遍历的思路：递归在一定意义上就是将每一步操作入栈然后在满足停止入栈时开始出栈，所以对于二叉树的非递归遍历，也是借用栈，通过对节点的出栈入栈，实现各种遍历。

    （1）先序遍历

            ①思路：

                先序是：根左右，每一次都将一个节点出栈并访问节点数组，然后先入栈右非空节点，再入栈左非空节点（因为栈满足后进先出），直到栈空时结束遍历。

            ②代码实现：
template<class T>
void Binary_tree<T>::PreOrder_Op(Bt_Node<T>* &Tree)
{
	Bt_Node<T>* BtNode_Stack[MAXSIZE],*Stack_Top;		//BtNode_Stack[MAXSIZE]为节点指针数组，用于模拟栈操作，Stack_Top用于存放栈顶根节点
	int Top = -1;		//初始栈空
	if (Tree)			//根节点非空时
	{
		BtNode_Stack[++Top] = Tree;		//根节点入栈
		while (Top > -1)		//栈非空时，遍历
		{
			Stack_Top = BtNode_Stack[Top--];		//将栈顶节点出栈
			cout << Stack_Top->Data << endl;

			if (Stack_Top->Right_Child != NULL)			//右孩子非空先入栈
				BtNode_Stack[++Top] = Stack_Top->Right_Child;
			if (Stack_Top->Left_Child != NULL)			//左孩子非空再入栈
				BtNode_Stack[++Top] = Stack_Top->Left_Child;
		}
	}
}

    （2)中序遍历

            ①思路：

                    中序：左根右，中序都是从树的最左边节点开始遍历的，所以对于每个节点下属的子树，都是找到该子树的最左节点，将该方向上的节点全部入栈，然后在栈非空的条件下出栈一个节点，访问该节点的数据，后入栈该节点的右节点，直到当前节点空并且栈空时结束遍历。

            ②代码实现：
template<class T>
void Binary_tree<T>::InOrder_Op(Bt_Node<T>* &Tree)
{
	Bt_Node<T>* BtNode_Stack[MAXSIZE], *Stack_Top;		//BtNode_Stack[MAXSIZE]为节点指针数组，用于模拟栈操作，Stack_Top用于存放栈顶根节点
	int Top = -1;		//初始栈空
	if (Tree)//根节点非空下
	{
		Stack_Top = Tree;		//根节点
		while (Top > -1 || Stack_Top)		//如果栈非空或者节点非空
		{
			while (Stack_Top)			//将该方向上所有的左孩子（包括当前的双亲节点入栈）
			{
				BtNode_Stack[++Top] = Stack_Top;
				Stack_Top = Stack_Top->Left_Child;
			}
			if (Top > -1)		//栈非空时可以访问
			{
				Stack_Top = BtNode_Stack[Top--];		//出栈节点
				cout << Stack_Top->Data << endl;		//访问该节点元素
				Stack_Top = Stack_Top->Right_Child;		//指向右孩子节点
			}
		}
	}
}

    （3)后序遍历

            ①思路：

                与中序遍历相同，都是将左节点沿最左方向先入栈，但因为后续遍历的根节点是最后被访问的，所以要出栈必须满足它的左右节点均被访问，所以需要记录前一次访问的节点，如果当前节点的左子树节点刚好是前一次访问的节点，那么出栈原节点。分状态执行，一种状态是原节点模式（袖珍树的遍历），一种是新节点模式，需要入栈方向左树。

            ②代码：
template<class T>
void Binary_tree<T>::PostOrder_Op(Bt_Node<T>* &Tree)
{
	Bt_Node<T>* BtNode_Stack[MAXSIZE], *Stack_Top;		//BtNode_Stack[MAXSIZE]为节点指针数组，用于模拟栈操作，Stack_Top用于存放栈顶根节点
	Bt_Node<T> *Last_Check;				//保存刚访问过的节点
	int Top = -1;		//初始栈空
	int Flag;
	Stack_Top = Tree;
	if (Tree)		//根节点非空时进行遍历
	{
		do
		{
			while (Stack_Top)		//将该节点所有左孩子节点入栈
			{
				BtNode_Stack[++Top] = Stack_Top;
				Stack_Top = Stack_Top->Left_Child;
			}
			Last_Check = NULL;			//Last_Check指向栈顶节点的前一个已访问过的节点
			Flag = 1;				//Flag=1表示处理根节点，Flag=0表示处理新的节点，此时需要将该节点的所以左孩子入栈
			while (Top != -1 && Flag == 1)		//栈非空并且程序处于处理原节点状态
			{
				Stack_Top = BtNode_Stack[Top];
				if (Stack_Top->Right_Child == Last_Check)		//如果已经处理完右孩子节点或者右孩子节点为空，可以访问栈顶节点
				{
					cout << Stack_Top->Data << endl;
					Top--;
					Last_Check = Stack_Top;		//Last_Check指向刚刚访问过的节点
				}
				else               
				{
					Stack_Top = Stack_Top->Right_Child;		//准备处理右孩子节点
					Flag = 0;
				}
			}

		} while (Top!=-1);
	}
}

    (4)层次遍历

            ①思路：

                    不同于前三种遍历方式，层次遍历不能依靠完全递归实现，在上一篇二叉树递归实现中我介绍了一种方法是通过穷举二叉树的层数，并对每一层进行递归遍历，这种方法的优点是可以通过每一层遍历完换行清晰看出每一层的数据情况。而下面介绍的这种方法，是通过循环队列，循环入队根节点，左节点，右节点，模拟层次遍历，而说到循环队列，什么时候比较困我就发出来吧，毕竟压了特别久。

            ②代码：
template<class T>
void Binary_tree<T>::LevelOrder_Op(Bt_Node<T>* &Tree)
{
	Bt_Node<T> *Queue_Top;			//队头节点
	Bt_Node<T>* BtNode_Queue[MAXSIZE];			//定义循环队列
	int Front, Rear;			//队头，队尾
	Front = Rear = -1;
	BtNode_Queue[++Rear] = Tree;		//入队根节点
	while (Front != Rear)		//队未空
	{
		Front = (Front + 1) % MAXSIZE;		//循环队列特有的队头循环（通过取余实现）
		Queue_Top = BtNode_Queue[Front];		//将队头节点出队
		cout << Queue_Top->Data << endl;		//访问节点数据
		if (Queue_Top->Left_Child != NULL)		//左孩子节点非空入队
		{
			Rear = (Rear + 1) % MAXSIZE;
			BtNode_Queue[Rear] = Queue_Top->Left_Child;
		}
		if (Queue_Top->Right_Child != NULL)		//右孩子节点非空入队
		{
			Rear = (Rear + 1) % MAXSIZE;
			BtNode_Queue[Rear] = Queue_Top->Right_Child;
		}
	}
}

5.类实现代码（全部）

#include<iostream>
using namespace std;
#define MAXSIZE 100
template<class T>
struct Bt_Node
{
	T Data;
	Bt_Node* Left_Child;
	Bt_Node* Right_Child;
};
template<class T>
class Binary_tree
{
private:
	Bt_Node<T> *Tree;
	/*内部实现函数*/
	int Create_BTree(Bt_Node<T>* &Tree);			//创建二叉树（构造内调用）

	int Distory_BTree(Bt_Node<T>* &Tree);			//析构二叉树的递归子函数（在析构内调用）


	void PreOrder_Op(Bt_Node<T>* &Tree);				//先序遍历(非递归实现函数）

	void InOrder_Op(Bt_Node<T>* &Tree);					//中序遍历（非递归实现函数）

	void PostOrder_Op(Bt_Node<T>* &Tree);				//后序遍历（非递归实现函数）

	void LevelOrder_Op(Bt_Node<T>* &Tree);				//层次遍历的非递归子函数
public:
	/*接口函数*/
	Binary_tree();							//类构造
	~Binary_tree();							//析构
	void PreOrder();					//先序遍历
	void InOrder();						//中序遍历
	void PostOrder();
	void LevelOrder();						//层次遍历

};


/*template<class T>
int Binary_tree<T>::Create_BTree(Bt_Node<T>* &Tree)		//满二叉树和完全二叉树的创建方法（非递归）
{
	Bt_Node<T>* Bt_Node_List[MAXSIZE];		//创建节点指针数组
	//Bt_Node_List = new Bt_Node<T>*[MAXSIZE];
	Bt_Node<T>* Start_Node;
	T Data;
	int Index, FindParent;		//Index为树节点编号，FindParent是查找双亲节点的编号
	cin >> Index >> Data;		//输入树节点的编号及数据
	while (Index != 0 && Data != -1)		//编号不为0且输入数据为-1代表结束
	{
		Start_Node = new Bt_Node<T>;
		Start_Node->Data = Data;
		Start_Node->Left_Child = NULL;		//左孩子和右孩子节点先赋值空
		Start_Node->Right_Child = NULL;
		Bt_Node_List[Index] = Start_Node;
		if (Index != 1)		//当该节点不是根节点
		{
			FindParent = Index / 2;			//寻找该节点的双亲节点
			if (Index % 2)					//若该节点编号对2取余结果为1，说明该节点是其双亲节点的右孩子节点，否则为左孩子节点
				Bt_Node_List[FindParent]->Right_Child = Start_Node;			//双亲节点找到自己的孩子
			else
				Bt_Node_List[FindParent]->Left_Child = Start_Node;
		}
		cin >> Index >> Data;		//继续输入数据
	}
	Tree = Bt_Node_List[1];			//在节点地址数组的位置为1的节点为根节点
	return 1;
}*/
template<class T>
int Binary_tree<T>::Create_BTree(Bt_Node<T>* &Tree)
{
	T Data;
	cin >> Data;
	if (Data == -1)
		Tree = NULL;
	else
	{
		Tree = new Bt_Node<T>;
		Tree->Data = Data;
		Create_BTree(Tree->Left_Child);
		Create_BTree(Tree->Right_Child);
	}
	return 1;
}

template<class T>
int Binary_tree<T>::Distory_BTree(Bt_Node<T>* &Tree)
{
	if (Tree)
	{
		Bt_Node<T>* LeftTree = Tree->Left_Child;
		Bt_Node<T>* RightTree = Tree->Right_Child;
		//cout << Tree->Data << endl;
		delete Tree;
		if (LeftTree)
			Distory_BTree(LeftTree);
		if (RightTree)
			Distory_BTree(RightTree);
	}
	return 0;
}

template<class T>
void Binary_tree<T>::PreOrder_Op(Bt_Node<T>* &Tree)
{
	Bt_Node<T>* BtNode_Stack[MAXSIZE],*Stack_Top;		//BtNode_Stack[MAXSIZE]为节点指针数组，用于模拟栈操作，Stack_Top用于存放栈顶根节点
	int Top = -1;		//初始栈空
	if (Tree)			//根节点非空时
	{
		BtNode_Stack[++Top] = Tree;		//根节点入栈
		while (Top > -1)		//栈非空时，遍历
		{
			Stack_Top = BtNode_Stack[Top--];		//将栈顶节点出栈
			cout << Stack_Top->Data << endl;

			if (Stack_Top->Right_Child != NULL)			//右孩子非空先入栈
				BtNode_Stack[++Top] = Stack_Top->Right_Child;
			if (Stack_Top->Left_Child != NULL)			//左孩子非空再入栈
				BtNode_Stack[++Top] = Stack_Top->Left_Child;
		}
	}
}

template<class T>
void Binary_tree<T>::InOrder_Op(Bt_Node<T>* &Tree)
{
	Bt_Node<T>* BtNode_Stack[MAXSIZE], *Stack_Top;		//BtNode_Stack[MAXSIZE]为节点指针数组，用于模拟栈操作，Stack_Top用于存放栈顶根节点
	int Top = -1;		//初始栈空
	if (Tree)//根节点非空下
	{
		Stack_Top = Tree;		//根节点
		while (Top > -1 || Stack_Top)		//如果栈非空或者节点非空
		{
			while (Stack_Top)			//将该方向上所有的左孩子（包括当前的双亲节点入栈）
			{
				BtNode_Stack[++Top] = Stack_Top;
				Stack_Top = Stack_Top->Left_Child;
			}
			if (Top > -1)		//栈非空时可以访问
			{
				Stack_Top = BtNode_Stack[Top--];		//出栈节点
				cout << Stack_Top->Data << endl;		//访问该节点元素
				Stack_Top = Stack_Top->Right_Child;		//该节点的右孩子节点入栈
			}
		}
	}
}

template<class T>
void Binary_tree<T>::PostOrder_Op(Bt_Node<T>* &Tree)
{
	Bt_Node<T>* BtNode_Stack[MAXSIZE], *Stack_Top;		//BtNode_Stack[MAXSIZE]为节点指针数组，用于模拟栈操作，Stack_Top用于存放栈顶根节点
	Bt_Node<T> *Last_Check;				//保存刚访问过的节点
	int Top = -1;		//初始栈空
	int Flag;
	Stack_Top = Tree;
	if (Tree)		//根节点非空时进行遍历
	{
		do
		{
			while (Stack_Top)		//将该节点所有左孩子节点入栈
			{
				BtNode_Stack[++Top] = Stack_Top;
				Stack_Top = Stack_Top->Left_Child;
			}
			Last_Check = NULL;			//Last_Check指向栈顶节点的前一个已访问过的节点
			Flag = 1;				//Flag=1表示处理根节点，Flag=0表示处理新的节点，此时需要将该节点的所以左孩子入栈
			while (Top != -1 && Flag == 1)		//栈非空并且程序处于处理原节点状态
			{
				Stack_Top = BtNode_Stack[Top];
				if (Stack_Top->Right_Child == Last_Check)		//如果已经处理完右孩子节点或者右孩子节点为空，可以访问栈顶节点
				{
					cout << Stack_Top->Data << endl;
					Top--;
					Last_Check = Stack_Top;		//Last_Check指向刚刚访问过的节点
				}
				else               
				{
					Stack_Top = Stack_Top->Right_Child;		//准备处理右孩子节点
					Flag = 0;
				}
			}

		} while (Top!=-1);
	}
}

template<class T>
void Binary_tree<T>::LevelOrder_Op(Bt_Node<T>* &Tree)
{
	Bt_Node<T> *Queue_Top;			//队头节点
	Bt_Node<T>* BtNode_Queue[MAXSIZE];			//定义循环队列
	int Front, Rear;			//队头，队尾
	Front = Rear = -1;
	BtNode_Queue[++Rear] = Tree;		//入队根节点
	while (Front != Rear)		//队未空
	{
		Front = (Front + 1) % MAXSIZE;		//循环队列特有的队头循环（通过取余实现）
		Queue_Top = BtNode_Queue[Front];		//将队头节点出队
		cout << Queue_Top->Data << endl;		//访问节点数据
		if (Queue_Top->Left_Child != NULL)		//左孩子节点非空入队
		{
			Rear = (Rear + 1) % MAXSIZE;
			BtNode_Queue[Rear] = Queue_Top->Left_Child;
		}
		if (Queue_Top->Right_Child != NULL)		//右孩子节点非空入队
		{
			Rear = (Rear + 1) % MAXSIZE;
			BtNode_Queue[Rear] = Queue_Top->Right_Child;
		}
	}
}




template<class T>
Binary_tree<T>::Binary_tree()
{
	Create_BTree(Tree);
}

template<class T>
Binary_tree<T>::~Binary_tree()
{
	Distory_BTree(Tree);
}

template<class T>
void Binary_tree<T>::PreOrder()
{
	PreOrder_Op(Tree);
}

template<class T>
void Binary_tree<T>::InOrder()
{
	InOrder_Op(Tree);
}


template<class T>
void Binary_tree<T>::PostOrder()
{
	PostOrder_Op(Tree);
}

template<class T>
void Binary_tree<T>::LevelOrder()
{
	LevelOrder_Op(Tree);
}



日常BB:

    这算是这半年来觉得最难啃的代码了，可能自己比较弱鸡，不过的确写完之后我自己都还是对整个过程有点模糊，慢慢看吧~共勉，其实后面还有难的，就是将二叉树线索化，重点来了，下篇见~

Cai-Crayon
关注
专栏目录
数据结构之二叉树的递归与非递归遍历
爱科比的博客
04-16 693
一、二叉树 在计算机科学中，树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按分支关系组织起来的结构。二叉树是每个节点最多有两个子树的有序树。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。值得注意的是，二叉树不是树的特殊情形。在图论中，二叉树是一个连通的无环图，并且每一个顶点的度不大于3。...
数据结构——二叉树的非递归遍历
L_T_W_Y的博客
09-03 284
先说一下：二叉树的非递归遍历的基本思路：使用堆栈 下面是用到的栈的存储结构以及基本操作，代码如下： /*非递归遍历中栈存储结构：包括栈的容量，栈顶指针和栈底指针。代码如下：*/ typedef struct { bst *base; bst *top; int stacksize; }stack; /*非递归遍历中所用到的栈的基本操作：代码如下：*/ int initialstack(stack &s)//初始化栈 { s.base=new bst[200];
数据结构篇：二叉树（二：二叉树的非递归遍历）
设计师养成记
10-29 464
         二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就 是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。 递归遍历：https://blog.csdn.net/qq_15020543/article/details/83216722 而对于树的遍历若采用非递归...
数据结构--非递归实现二叉树的先序,中序,后序遍历
【Dyson】的博客
08-20 612
        如上图所示 : 二叉树的先序遍历顺序为: A B D C E F                                    中序遍历顺序为 : D B A E C F                                    后序遍历顺序为 : D B E F C A 先序遍历(非递归) : 方法一 : 先将元素左边全部入栈 , 入栈同时打印入...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
数据结构-非递归遍历二叉树
11-16
非递归遍历二叉树是一种不依赖递归函数来访问树的所有节点的方法，它通常通过栈或队列等数据结构来实现。下面我们将详细探讨非递归遍历二叉树的先序、中序和后序策略。 先序遍历是二叉树遍历的一种方法，其顺序为：...
c代码-递归创建二叉树，先序、中序、后序递归遍历二叉树
07-14
下面将详细解释如何使用C代码实现递归创建二叉树以及三种主要的递归遍历方法：先序遍历、中序遍历和后序遍历。 首先，我们需要定义一个二叉树节点的结构体： ```c typedef struct TreeNode { int val; // 节点的...
完全二叉树 -- 已知先序遍历,求中序遍历
llCnll的博客
11-11 1875
大体思路 一直*2, 直到小于总结点数, – 左节点 在(1)不成立的情况下+1, 并且要注意临界点(下标不能超过总结点数和因为是先序, 所以父节点存在) – 右节点 由左节点产生的树遍历完, 要找其兄弟节点 详细思路见代码 具体实现 #include <stdio.h> #define MAX 100 int tree[MAX]; int tmp[MAX]; void in...
数据结构C++二叉树的先序遍历、中序遍历和后序遍历实现
12-06
数据结构C++二叉链表的先序遍历、中序遍历和后序遍历实现
[数据结构]对中序非递归遍历二叉树的理解与讨论
飞鱼天空
08-10 6509
中序遍历二叉树，即是先遍历左子树，再访问根节点，最后遍历右子树，这个顺序对于每棵子树都是一样的，是访问子树的共性，故可依次顺序设置循环，逐一访问每个结点。对于每一个树的子树，均要完成此操作。故在开始遍历之时，应先找到最左边的结点，遍历应从此开始。访问完此结点，应逐一访问此结点的根结点和右子树。有点难度的第一是找最左节点。方法是从树的根结点顺lchild而下直到NULL为止。二是访问完根节点后以中序
数据结构 树笔记-7 二叉树的非递归中序遍历
linking_lin的博客
05-22 215
二叉树的 非递归 中序遍历//#define ElemType char typedef char ElemType;结点中存放的数据的类型的定义  typedef struct BiTNode{树结点的定义    ElemType data;     struct BiTNode *lchild, *rchild; }BiTNode, *BiTree;BiTNode是一个结构体变量；BiTree...
数据结构 树笔记-6 二叉树的非递归先序遍历
linking_lin的博客
05-17 221
如下这棵二叉树的先序遍历结果为：ABDEFPC针对于上面的这棵二叉树，结合代码，讲述遍历过程：#include &lt;stdio.h&gt;#include &lt;malloc.h&gt; //#define ElemType chartypedef char ElemType; typedef struct BiTNode{    ElemType data;    struct BiTNo...
非递归方法实现二叉树的先序遍历、中序遍历、后序遍历
Aaron_1934的博客
05-07 324
用递归方法实现二叉树的先序遍历、中序遍历和后序遍历很简单：class Solution { public: vector&lt;int&gt; preOrder; vector&lt;int&gt; preorderTraversal(TreeNode *root) {    // 先序遍历，4ms，484k if(root == nullptr) ...
数据结构——二叉树的递归与非递归遍历（先序，中序，后序）
辞树
12-18 1万+
实验项目五 二叉树基本操作的实现 课程名称：数据结构 实验项目名称：二叉树基本操作的实现 实验目的： 1．掌握树的基本操作—遍历。 实验要求： 1、 分别用递归和非递归的方法实现一棵树的三种遍历。 实验过程： 1、 创建一棵二叉树（二叉树如下图所示）； 2、 用递归算法实现对该树的三种遍历； 3、 用非递归算法实现对该树的三种遍历； 4、 输入选项
递归与非递归实现二叉树的遍历
soygrow的博客
02-02 396
非递归实现二叉树的后续遍历 首先后续遍历可以使用递归来实现。一般情况下，能用递归实现的问题都可以用栈来解决，只是递归更符合人的思维方式，代码相对来说较简单。但是不能说明递归的方式比栈的方式更快、更省空间，因为在递归过程中都是操作系统帮助用栈实现存储信息。 下面使用递归的方式实现二叉树的后续遍历（包括先序和中序的实现，方法大致相同）： //递归实现后续遍历二叉树 void RecursionB
二叉树的遍历（非递归）
wang_cheng_hei的专栏
02-27 720
二叉树的先序遍历 void preorder(Btree *root) { Btree *p=root; stacks; while(p!=NULL||!s.empty()) { while(p!=NULL) { coutdata<<" "; s.push(p); p=p->lchild; } if(!s.empty()) { p=s.to
数据结构 ：二叉树前序/中序/后序遍历的递归与循环实现
Mr. Stone's Blog
10-16 238
转载自https://www.cnblogs.com/yinheyi/p/10668108.html   对于二叉树的三种遍历方法， 递归方法实现起来简单，明白。但是效率不好，并且不安全，可能会栈溢出。循环的实现，肯定是基于栈的数据结构来实现，要复杂一些。代码如下：   前序遍历的实现： // 前序遍历 ----基于递归 void PreorderTraversal(...
非递归实现二叉树遍历.c
封雷的博客
12-17 94
#include "BTree.h" #include &lt;stdio.h&gt; #include "LinkQueue.h" #include "LinkStack.h" void printData(BTreeNode* node) { printf ("%c\n", node-&gt;data); } void pre_order(BTreeNode *root) { if ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值