二叉树的遍历算法（递归、层次、非递归）(c++)

最新推荐文章于 2024-07-28 17:42:24 发布
最新推荐文章于 2024-07-28 17:42:24 发布
阅读量378 收藏 1
点赞数
分类专栏： 二叉树 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qiuhongim/article/details/116714932
版权

二叉树的遍历算法（递归、层次、非递归）

递归、层次遍历算法

先序遍历

  • 若二叉树为空，遍历结束；否则，先根结点、再左子树、后右子树
/*
//二叉链表结点定义
template <class T>
class BiTreeNode
{
public:
	T data;	//数据域
	BiTreeNode<T>* lchild;	//左孩子指针域
	BiTreeNode<T>* rchild;	//右孩子指针域
};
*/

template<typename T>
void BiTree<T>::PreOrder(BiTreeNode<T>* bt)
{
	if (bt == NULL)		//递归调用的结束条件
	{
		return;
	}
	cout << bt->data;	//访问根结点bt的数据域
	PreOrder(bt->lchild);	//先序递归遍历bt的左子树
	PreOrder(bt->rchild);	//先序遍历bt的右子树
}

中序遍历

  • 若二叉树为空，遍历结束；否则，先左子树、再根结点、后右子树
/*
//二叉链表结点定义
template <class T>
class BiTreeNode
{
public:
	T data;	//数据域
	BiTreeNode<T>* lchild;	//左孩子指针域
	BiTreeNode<T>* rchild;	//右孩子指针域
};
*/

template<typename T>
void BiTree<T>::InOrder(BiTreeNode<T>* bt)
{
	if (bt == NULL)
	{
		return;
	}
	InOrder(bt->lchild);
	cout << bt->data;
	InOrder(bt->rchild);
}

后序遍历

  • 若二叉树为空，遍历结束；否则，先左子树、再右子树、后根结点
/*
//二叉链表结点定义
template <class T>
class BiTreeNode
{
public:
	T data;	//数据域
	BiTreeNode<T>* lchild;	//左孩子指针域
	BiTreeNode<T>* rchild;	//右孩子指针域
};
*/

template<typename T>
void BiTree<T>::PostOrder(BiTreeNode<T>* bt)
{
	if (bt == NULL)
	{
		return;
	}
	PostOrder(bt->lchild);
	PostOrder(bt->rchild);
	cout << bt->data;
}

层次遍历

  • 二叉树的层次遍历是指从二叉树的根结点开始，从上往下、从左往右逐层遍历，对一层结点访问完以后，再按照它们的访问次序依次访问各个结点的左、右孩子，这样一层一层地进行，先遇到的结点先访问，符合队列操作规则。

  • 首先将根结点入队，然后从队头取一个元素，每取一个元素，执行如下3个动作：

    1. 访问该元素所指结点
    2. 如果该元素所指结点有左孩子，则左孩子指针入队
    3. 如果该元素所指结点右有孩子，则右孩子指针入队

    重复以上操作，知道队列为空

  • 算法具体实现代码

/*
//所需队列定义
const int QUEUE_MAX_SIZE = 100;	//默认队列大小为100
template <class T>
class Queue
{
public:
	T data[QUEUE_MAX_SIZE];
	int front, rear;
};

//二叉链表结点定义
template <class T>
class BiTreeNode
{
public:
	T data;	//数据域
	BiTreeNode<T>* lchild;	//左孩子指针
	BiTreeNode<T>* rchild;	//右孩子指针
};
*/

template<typename T>
void BiTree<T>::LevelOrder(BiTreeNode<T>* bt)
{
	if (bt == NULL)
	{
		return;	//空树
	}
	Queue<BiTreeNode<T>*> Q;
	Q.front = Q.rear = -1;
	Q.data[++Q.rear] = root;
	while (Q.rear != Q.front)
	{
		BiTreeNode<T>* q = Q.data[++Q.front];	//出队
		cout << q->data;
		if (q->lchild != NULL)	//左孩子入队
		{
			Q.data[++Q.rear] = q->lchild;
		}
		if (q->rchild != NULL)	//右孩子入队
		{
			Q.data[++Q.rear] = q->rchild;
		}
	}
}

完整代码（c++）

#pragma once
#include <iostream>

using namespace std;

//层次遍历所需队列定义
const int QUEUE_MAX_SIZE = 100;	//默认队列大小为100
template <class T>
class Queue
{
public:
	T data[QUEUE_MAX_SIZE];
	int front, rear;
};

//二叉链表结点定义
template <class T>
class BiTreeNode
{
public:
	T data;	//数据域
	BiTreeNode<T>* lchild;	//左孩子指针
	BiTreeNode<T>* rchild;	//右孩子指针
};

//二叉链表类实现
template <class T>
class BiTree
{
private:
	BiTreeNode<T>* root;					//指向根结点的头结点
	BiTreeNode<T>* Creat(BiTreeNode<T>* bt);//构造函数调用
	void Release(BiTreeNode<T>* bt);		//析构函数调用
	void PreOrder(BiTreeNode<T>* bt);		//DLR
	void InOrder(BiTreeNode<T>* bt);		//LDR
	void PostOrder(BiTreeNode<T>* bt);		//LRD
	void LevelOrder(BiTreeNode<T>* bt);		//层次遍历	
public:
	BiTree() { root = Creat(root); };		//构造函数  构建一棵二叉树
	~BiTree() { Release(root); };			//析构函数	释放个结点的空间
	void PreOrder() { PreOrder(root); };	//DLR
	void InOrder() { InOrder(root); };		//LDR
	void PostOrder() { PostOrder(root); };	//LDR
	void LeverOrder() { LevelOrder(root); };//层次遍历
};

template <typename T>
BiTreeNode<T>* BiTree<T>::Creat(BiTreeNode<T>* bt)
{
	T ch;
	cin >> ch;	//输入结点的数据信息  假定为字符
	if (ch == '#')
	{
		bt = NULL;	//建立一棵空树
	}
	else
	{
		bt = new BiTreeNode<T>;	//生成一个结点，数据域为ch
		bt->data = ch;
		bt->lchild = Creat(bt->lchild);	//递归建立左子树
		bt->rchild = Creat(bt->rchild);	//递归建立右子树
	}
	return bt;
}

template<typename T>
void BiTree<T>::Release(BiTreeNode<T>* bt)
{
	if (bt != NULL)
	{
		Release(bt->lchild);	//释放左子树
		Release(bt->rchild);	//释放右子树
		delete bt;	//释放根结点
	}
}

template<typename T>
void BiTree<T>::PreOrder(BiTreeNode<T>* bt)
{
	if (bt == NULL)		//递归调用的结束条件
	{
		return;
	}
	cout << bt->data;	//访问根结点bt的数据域
	PreOrder(bt->lchild);	//先序递归遍历bt的左子树
	PreOrder(bt->rchild);	//先序遍历bt的右子树
}

template<typename T>
void BiTree<T>::InOrder(BiTreeNode<T>* bt)
{
	if (bt == NULL)
	{
		return;
	}
	InOrder(bt->lchild);
	cout << bt->data;
	InOrder(bt->rchild);
}

template<typename T>
void BiTree<T>::PostOrder(BiTreeNode<T>* bt)
{
	if (bt == NULL)
	{
		return;
	}
	PostOrder(bt->lchild);
	PostOrder(bt->rchild);
	cout << bt->data;
}
template<typename T>
void BiTree<T>::LevelOrder(BiTreeNode<T>* bt)
{
	if (bt == NULL)
	{
		return;	//空树
	}
	Queue<BiTreeNode<T>*> Q;
	Q.front = Q.rear = -1;
	Q.data[++Q.rear] = root;
	while (Q.rear != Q.front)
	{
		BiTreeNode<T>* q = Q.data[++Q.front];	//出队
		cout << q->data;
		if (q->lchild != NULL)	//左孩子入队
		{
			Q.data[++Q.rear] = q->lchild;
		}
		if (q->rchild != NULL)	//右孩子入队
		{
			Q.data[++Q.rear] = q->rchild;
		}
	}
}

int main()
{
    cout << "请按先序输入二叉树的各个结点（空用#符号表示）：" << endl;
	BiTree<char>* bitree = new BiTree<char>();	//创建一棵二叉树
    
	cout << "先序遍历如下：" << endl;
	bitree->PreOrder();
	cout << endl;

	cout << "中序遍历如下：" << endl;
	bitree->InOrder();
	cout << endl;

	cout << "后序遍历如下：" << endl;
	bitree->PostOrder();
	cout << endl;

	cout << "层次遍历如下：" << endl;
	bitree->LeverOrder();
	cout << endl;

	system("pause");

	return 0;
}
  • 输出
    在这里插入图片描述

非递归遍历算法

算法思想

  • 从根结点开始沿左子树深入下去，当到达左子树最左端时，返回；当返回的结点存在右子树，进入该结点右子树，再进行如此深入和返回，直到最后从根结点的右子树返回到根结点

  • 遍历路程图（ △ 表示先序遍历路线，* 表示中序遍历路线，★表示后序遍历路线）
    在这里插入图片描述

    先序遍历：结点第一次遇到时访问结点

    中序遍历：结点第二次遇到时访问结点（从左子树返回后访问）

    后序遍历：结点第三次遇到时访问结点（从右子树返回后访问）

算法实现所需的数据类型—栈

  • 在不断深入返回过程中，先深入的后返回，符合栈的特征

先序遍历

算法策略

  • 从根结点沿左子树深入，每深入一个结点，就入栈并访问一个，当到达最左端时，返回，当结点返回时出栈，然后从该结点右子树继续深入，如此进行下去，直到从根结点的右子树返回

遍历算法（c++）

/*
const int MAXNODE = 10;	//默认二叉树最大结点为10
//二叉链表结点定义
template <class T>
class BiTreeNode
{
public:
	T data;				//数据域
	BiTreeNode* lchild;	//左孩子指针域
	BiTreeNode* rchild;	//右孩子指针域
};
*/

/*先序遍历（非递归）*/
template <typename T>
void BiTree<T>::PreOrder(BiTreeNode<T>* bt)
{
	BiTreeNode<T>* s[MAXNODE];	//定义栈S  用于暂时存储二叉树结点
	BiTreeNode<T>* p = bt;
	int top = -1;
	if (bt == NULL)
	{
		return;	//空树
	}
	while (!(p == NULL && top == -1))
	{
		while (p != NULL)
		{
			if (top < MAXNODE - 1)
			{
				++top;
				s[top] = p;
			}
			else
			{
				cout << "Stack OverFlow!" << endl;
			}
			cout << p->data;	//访问结点数据域
			p = p->lchild;
		}
		if (top == -1)
		{
			return;	//栈空结束
		}
		else
		{
			p = s[top];	//弹出栈顶元素
			--top;
			p = p->rchild;
		}
	}
}

中序遍历

算法策略

  • 从根结点沿左子树深入，每深入一个结点，就入栈一个，当到达最左端时，返回，当结点返回时出栈并访问，然后从该结点右子树继续深入，如此进行下去，直到从根结点的右子树返回

遍历算法（c++）

/*
const int MAXNODE = 10;	//默认二叉树最大结点为10
//二叉链表结点定义
template <class T>
class BiTreeNode
{
public:
	T data;				//数据域
	BiTreeNode* lchild;	//左孩子指针域
	BiTreeNode* rchild;	//右孩子指针域
};
*/

/*中序遍历（非递归）*/
template <typename T>
void BiTree<T>::InOrder(BiTreeNode<T>* bt)
{
	BiTreeNode<T>* s[MAXNODE];	//定义栈S  用于暂时存储二叉树结点
	BiTreeNode<T>* p = bt;
	int top = -1;	
	if (bt == NULL)
	{
		return;	//空树
	}
	while (!(p == NULL && top == -1))
	{
		while (p != NULL)
		{
			if (top < MAXNODE - 1)
			{
				++top;
				s[top] = p;
			}
			else
			{
				cout << "Stack OverFlow!" << endl;
			}
			p = p->lchild;
		}
		if (top == -1)
		{
			return;	//栈空结束
		}
		else
		{
			p = s[top];	//弹出栈顶元素
			--top;
			cout << p->data;	//访问结点数据域
			p = p->rchild;
		}
	}
}

后序遍历

算法策略

  • 由于后序遍历是从右子树返回时才访问结点，因此存在两种情况
    1. 结点没有右孩子
    2. 结点有右孩子
  • 因此我们需要一个辅助指针用于标记结点是从左子树返回还是右子树返回，当结点属于情况一，直接弹出并访问，修改辅助指针指向该结点，之后继续访问栈顶元素，当栈顶元素属于情况二，入栈，继续深入该结点左子树并入栈，如此进行下去，每弹出一个结点，都修改辅助指针指向该结点。

遍历算法（c++）

/*
const int MAXNODE = 10;	//默认二叉树最大结点为10
//二叉链表结点定义
template <class T>
class BiTreeNode
{
public:
	T data;				//数据域
	BiTreeNode* lchild;	//左孩子指针域
	BiTreeNode* rchild;	//右孩子指针域
};
*/

/*后序遍历（非递归）*/
template <typename T>
void BiTree<T>::PostOrder(BiTreeNode<T>* bt)
{
	BiTreeNode<T>* s[MAXNODE];	//定义栈S  用于暂时存储二叉树结点
	BiTreeNode<T>* p = bt;
	BiTreeNode<T>* r = NULL;	//辅助指针,用于标记是从左或右子树返回
	int top = -1;
	if (bt == NULL)
	{
		return;	//空树
	}
	while (!(p == NULL && top == -1))	//栈非空且二叉树非空
	{
		while (p != NULL)	
		{
			if (top < MAXNODE - 1)
			{
				++top;
				s[top] = p;
			}
			else
			{
				cout << "Stack OverFlow!" << endl;
			}
			p = p->lchild;
		}
		if (top == -1)
		{
			return;	//栈空结束
		}
		else
		{
			p = s[top];
			if (p->rchild && p->rchild != r)	//存在右子树，并且未被访问过
			{
				p = p->rchild;
				++top;
				s[top] = p;
				p = p->lchild;
			}
			else								//不存在右子树或已经访问完了
			{
				--top;
				cout << p->data;
				r = p;
				p = NULL;
			}
		}
	}
}

完整代码（c++）

#pragma once
#include <iostream>

const int MAXNODE = 10;	//默认二叉树最大结点为10

using namespace std;

/*二叉链表结点定义*/
template <class T>
class BiTreeNode
{
public:
	T data;				//数据域
	BiTreeNode* lchild;	//左孩子指针域
	BiTreeNode* rchild;	//右孩子指针域
};

/*二叉链表类实现*/
template <class T>
class BiTree
{
public:
	BiTree() { root = PreCreate(root); };			//构造函数
	~BiTree() { Release(root); };					//析构函数
	void PreOrder() { PreOrder(root); };			//DLR
	void InOrder() { InOrder(root); };				//LDR
	void PostOrder() { PostOrder(root); };			//LRD
private:
	BiTreeNode<T>* root;							//二叉树根结点
	BiTreeNode<T>* PreCreate(BiTreeNode<T>* bt);	//先序创建二叉树（递归）
	void Release(BiTreeNode<T>* bt);				//释放结点（递归）
	void PreOrder(BiTreeNode<T>* bt);				//先序遍历（非递归）
	void InOrder(BiTreeNode<T>* bt);				//中序遍历（非递归）
	void PostOrder(BiTreeNode<T>* bt);				//后序遍历（非递归）
};

/*先序创建二叉树（递归）*/
template <typename T>
BiTreeNode<T>* BiTree<T>::PreCreate(BiTreeNode<T>* bt)
{
	T ch;
	cin >> ch;
	if (ch == '#')
	{
		bt = NULL;
	}
	else
	{
		bt = new BiTreeNode<T>;
		bt->data = ch;
		bt->lchild = PreCreate(bt->lchild);
		bt->rchild = PreCreate(bt->rchild);
	}
	return bt;
}

/*释放结点（递归）*/
template <typename T>
void BiTree<T>::Release(BiTreeNode<T>* bt)
{
	if (bt != NULL)
	{
		Release(bt->lchild);
		Release(bt->rchild);
		delete bt;
	}
}

/*先序遍历（非递归）*/
template <typename T>
void BiTree<T>::PreOrder(BiTreeNode<T>* bt)
{
	BiTreeNode<T>* s[MAXNODE];	//定义栈S  用于暂时存储二叉树结点
	BiTreeNode<T>* p = bt;
	int top = -1;
	if (bt == NULL)
	{
		return;	//空树
	}
	while (!(p == NULL && top == -1))
	{
		while (p != NULL)
		{
			if (top < MAXNODE - 1)
			{
				top++;
				s[top] = p;
			}
			else
			{
				cout << "Stack OverFlow!" << endl;
			}
			cout << p->data;	//访问结点数据域
			p = p->lchild;
		}
		if (top == -1)
		{
			return;	//栈空结束
		}
		else
		{
			p = s[top];	//弹出栈顶元素
			--top;
			p = p->rchild;
		}
	}
}
/*中序遍历（非递归）*/
template <typename T>
void BiTree<T>::InOrder(BiTreeNode<T>* bt)
{
	BiTreeNode<T>* s[MAXNODE];	//定义栈S  用于暂时存储二叉树结点
	BiTreeNode<T>* p = bt;
	int top = -1;	
	if (bt == NULL)
	{
		return;	//空树
	}
	while (!(p == NULL && top == -1))
	{
		while (p != NULL)
		{
			if (top < MAXNODE - 1)
			{
				top++;
				s[top] = p;
			}
			else
			{
				cout << "Stack OverFlow!" << endl;
			}
			p = p->lchild;
		}
		if (top == -1)
		{
			return;	//栈空结束
		}
		else
		{
			p = s[top];	//弹出栈顶元素
			--top;
			cout << p->data;	//访问结点数据域
			p = p->rchild;
		}
	}
}

/*后序遍历（非递归）*/
template <typename T>
void BiTree<T>::PostOrder(BiTreeNode<T>* bt)
{
	BiTreeNode<T>* s[MAXNODE];	//定义栈S  用于暂时存储二叉树结点
	BiTreeNode<T>* p = bt;
	BiTreeNode<T>* r = NULL;	//辅助指针,用于标记是从左或右子树返回
	int top = -1;
	if (bt == NULL)
	{
		return;	//空树
	}
	while (!(p == NULL && top == -1))	//栈非空且二叉树非空
	{
		while (p != NULL)	//
		{
			if (top < MAXNODE - 1)
			{
				top++;
				s[top] = p;
			}
			else
			{
				cout << "Stack OverFlow!" << endl;
			}
			p = p->lchild;
		}
		if (top == -1)
		{
			return;	//栈空结束
		}
		else
		{
			p = s[top];
			if (p->rchild && p->rchild != r)
			{
				p = p->rchild;
				top++;
				s[top] = p;
				p = p->lchild;
			}
			else
			{
				--top;
				cout << p->data;
				r = p;
				p = NULL;
			}
		}
	}
}

int main()
{
	cout << "请按先序遍历输入二叉树（空节点用#表示）：" << endl;
	BiTree<char>* bitree = new BiTree<char>();

	cout << "先序遍历（非递归）如下：" << endl;
	bitree->PreOrder();
	cout << endl;

	cout << "中序遍历（非递归）如下：" << endl;
	bitree->InOrder();
	cout << endl;

	cout << "后序遍历（非递归）如下：" << endl;
	bitree->PostOrder();
	cout << endl;

	system("pause");

	return 0;
}
  • 输出
    在这里插入图片描述
JauWang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的四种遍历（递归与非递归）
qq_46388795的博客
10-07 194
先序遍历与后序遍历 先序遍历根节点，再遍历左子树，再遍历右子树。 后序遍历先遍历左子树，再遍历右子树，再遍历根节点。 先序遍历递归实现： public static void preOrderByRecursion(TreeNode root) { // 打印节点值 System.out.println(root.value); preOrder(root.left); preOrder(root.right); } 先序遍历的非递归实现： 非递归实现需要借助
二叉树的遍历（递归和非递归算法）
further_的博客
08-31 1041
事实上，当使用递归时，二叉树的遍历算法基本一样，只不过是访问结点的顺序和输出结点的顺序不同。先了解下面这个有利于详细学习时的快速理解。 先序----根、左子树、右子树； 中序—左子树、根、右子树； 后序—左子树、右子树、根 层次遍历，从上到下、从左到右 下面是下面代码会用到的。 //二叉树的二叉链存储表示可描述为： typedef struct node{ ElemType data; /* 存放结点的值，ElemType是元素的基本类型 */ struct node *lchild; /* 指
二叉树的遍历算法
04-09
二叉树的遍历算法一、概念 1.树型结构是一类非常重要的非线性数据结构，其中以树和二叉树最为常用； 2.非线性结构是指数据之间的关系是一对多或者多对多，线性结构就是数据之间的关系是一对一的
二叉树的遍历
虫师
04-18 212
二叉树的遍历有三种方式，如下： （1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。简记根-左-右。 （2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。简记左-根-右。 （3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。简记左-右-根。 例1：如上图所示的二叉树，若按前序遍历，则其输出...
二叉树的遍历（先序、中序、后序、层次）
最新发布
kusunoki的博客
07-28 2918
参照王道数据结构辅导书以及哔哩哔哩大学的部分视频，对二叉树遍历的重要知识点进行归纳，并总结做题技巧。
二叉树遍历算法
weixin_30707875的博客
08-02 78
二叉树是一种非线性的数据结构，在对它进行操作时，总是需要逐一对每个数据元素实施操作，这样就存在一个操作顺序问题，由此提出了二叉树的遍历操作。所谓遍历二叉树就是按某种顺序访问二叉树中的每个结点一次且仅一次的过程。这里的访问可以是输出、比较、更新、查看元素内容等等各种操作。 在这里写了个二叉树遍历算法、根据三种不同的顺序得到三种不同的顺序结果、 public class Binar...
C++实现二叉树层次遍历
hou19975418的博客
01-23 347
配合队列容器queue的入队出队操作，就可以实现二叉树的层次遍历。
二叉树遍历算法（递归实现+层次遍历）
irabbit756的博客
08-23 3962
二叉树遍历算法 二叉树的存储结构 typedef struct BTNode { char data; //这里默认结点data为char型 struct BTNode *lchild; struct BTNode *rchild; }BTNode; 二叉树的遍历算法 1 先序遍历 先序遍历的操作如下。 如果二叉树为空树，则什么都不做；否则： 1）访问根节点 2）先序遍历左子树 3）先序遍历右子树 描述如下： void preorder(BTNode *p) { if(p
二叉树先序遍历、中序遍历和后序遍历非递归算法 C++源码
08-25
用C++写的二叉树先序遍历、中序遍历和后序遍历非递归算法
C++ 二叉树的先序遍历、中序遍历和后序遍历非递归算法
08-25
用C++写的，包括二叉树的构建，二叉树的先序遍历、中序遍历和后序遍历非递归算法。
C++：二叉树后序遍历的非递归
FamerSaul的博客
07-11 1109
后序遍历的非递归操作：出栈代表此根所在的子树已经访问完毕，不需要再入栈；因此需要判断当前栈顶根的右子树是不是上一个栈顶根元素。
二叉树中序遍历（递归法和迭代法(非递归法)）——C++
净无邪博客
12-04 1812
1.2迭代法 迭代法是采用非递归方法实现二叉树的中序遍历，主要利用数据结构std::stack来实现，利用栈std::stack的先进后出特性依次压入待访问的节点，然后依次按照中序遍历顺序弹出和访问节点，确保每个节点有且仅有一次访问。 具体步骤如下： a1 先将所有父节点和左子节点依次压入栈； 这样做的目的是为了先弹出左子节点，再弹出父节点，可以在弹出左子节点的时候进行遍历，同时处理右节点，比如将右节点压入栈，这样就实现了先访问左节点，然后父节点，最后右子节点。a2 然后弹出一个节点，进行遍历； 此时弹出a
二叉树的先序遍历、中序遍历、后序遍历、层次遍历-图文详解
热门推荐
古月哲亭
04-07 4万+
二叉树的遍历详解AProgrammer微信公众号：AProgrammer​关注他概述二叉树的遍历是一个很常见的问题。二叉树的遍历方式主要有：先序遍历、中序遍历、后序遍历、层次遍历。先序、中序、后序其实指的是父节点被访问的次序。若在遍历过程中，父节点先于它的子节点被访问，就是先序遍历；父节点被访问的次序位于左右孩子节点之间，就是中序遍历；访问完左右孩子节点之后再访问父节点，就是后序遍历。不论是先序遍...
二叉树遍历算法详解：递归与非递归实现
"这篇文档是关于二叉树遍历的课程设计报告，涵盖了...这个课程设计是全面理解和熟练应用二叉树遍历算法的重要实践，对于计算机科学的学习者来说，这是一个宝贵的锻炼机会，有助于他们建立坚实的理论基础和实践经验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值