最新出炉的二叉树的递归与非递归6种遍历方式，你都明白了吗？

二叉树的基本概念：
在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。
一棵深度为k，且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且或者最后一层是满的，或者是在右边缺少连续若干结点，则此二叉树为完全二叉树。具有n个结点的完全二叉树的深度为floor(log2n)+1。深度为k的完全二叉树，至少有2k-1个叶子结点，至多有2k-1个结点。
来自搜狗词条：https://baike.sogou.com/v111776.htm?fromTitle=%E4%BA%8C%E5%8F%89%E6%A0%91
更多深入的了解请关注哔哩哔哩up“懒猫老师”：
链接：https://space.bilibili.com/26340287/video
输入：
ABC##DE###GF#I##H##
预期输出：
经前序遍历后的结果为：A B C D E G F I H
经中序遍历后的结果为：C B E D A F I G H
经后序遍历后的结果为：C E D B I F H G A
经非递归前序遍历后的结果为：A B C D E G F I H
经非递归中序遍历后的结果为：C B E D A F I G H
经非递归后序遍历后的结果为：C E D B I F H G A
源码：仅供参考

#include <iostream>
#include <stack>
using namespace std;
//结点类型
class BiNode{
public :
	//数据域
	char data;
	//左右孩子指针
	BiNode *left_Child;
	BiNode *right_Child;
};
//二叉树类
class BiTree{
//用根结点表示一棵二叉树
public:
	BiNode *root;
	//构造函数
	BiTree::BiTree(){
		root = createTree(root);
	}
	//创建树
	BiNode* createTree(BiNode *bt);
	//递归前序遍历树
	void preOrderTraverse(BiNode *bt);
	//递归中序遍历树
	void inOrderTraverse(BiNode *bt);
	//递归后序遍历树
	void postOrderTraverse(BiNode* bt);
	//递归层次遍历树
	void leverOrderTravrse(BiNode* bt);

	//非递归前序遍历
	void unDiGuiPreOrderTraverse(BiNode* bt);
	//非递归中序遍历
	void unDiGuiInOrderTraverse(BiNode* bt);
	//非递归后序遍历
	void unDiGuiPostOrderTraverse(BiNode* bt);
};
//将指针和入栈次数标记temp封装成一个结构体
struct Flag{
	BiNode* ptr;
	int temp;
};
//建树
BiNode* BiTree::createTree(BiNode *bt){
	char ch;
	cin >> ch;
	if (ch == '#')
		bt = NULL;
	else{
		bt = new BiNode;
		bt->data = ch;
		bt->left_Child = createTree(bt->left_Child);
		bt->right_Child = createTree(bt->right_Child);
	}
	return bt;
}
//递归前序遍历树
void BiTree::preOrderTraverse(BiNode* bt){

	if (bt)
	{
		cout << bt->data <<" ";
		preOrderTraverse(bt->left_Child);
		preOrderTraverse(bt->right_Child);
	}else{
			return;
	}
}
//递归中序遍历树
void BiTree::inOrderTraverse(BiNode* bt){

	if (bt){
		inOrderTraverse(bt->left_Child);
		cout << bt->data << " ";
		inOrderTraverse(bt->right_Child);
	}
	else{
		return;
	}
}
//递归后序遍历树
void BiTree::postOrderTraverse(BiNode* bt){

	if (bt){
		postOrderTraverse(bt->left_Child);
		postOrderTraverse(bt->right_Child);
		cout << bt->data << " ";
	}
	else{
		return;
	}
}
	//非递归前序遍历
void BiTree::unDiGuiPreOrderTraverse(BiNode* bt){
	//创建一个指针栈
	stack<BiNode*> s;
	BiNode *p = bt;
	while (p != NULL || !s.empty()){//当p为空且栈也为空时才退出循环
		while (p != NULL){
			//访问根结点
			cout << p->data << " ";
			//将p指向的结点入栈
			s.push(p);
			//遍历左子树
			p = p->left_Child;
		}
		//栈不为空
		if (!s.empty()){
			//根结点出栈
			p = s.top();
			s.pop();
			//遍历右子树
			p = p->right_Child;
		}
	}
}

//非递归中序遍历(与前序十分类似)
void BiTree::unDiGuiInOrderTraverse(BiNode* bt){
	//创建一个指针栈
	stack<BiNode*> s;
	BiNode *p = bt;
	while (p != NULL || !s.empty()){//当p为空且栈也为空时才退出循环
		while (p != NULL){
			//将p指向的结点入栈
			s.push(p);
			//遍历左子树
			p = p->left_Child;
		}
		//栈不为空
		if (!s.empty()){
			//根结点出栈
			p = s.top();
			//访问根结点
			cout << p->data << " ";
			s.pop();
			//遍历右子树
			p = p->right_Child;
		}
	}
}
//非递归后序遍历(在后序遍历中结点要入两次栈，出两次栈，要加以区分将temp标记和指针封装成一个结构体)
void BiTree::unDiGuiPostOrderTraverse(BiNode* bt){
	//创建一个存储Flag的栈
	stack<Flag> s;
	Flag flag ;
	BiNode *p = bt;
	//当p为空且栈也为空时才退出循环
	while (p!=NULL||!s.empty()){
		if (p != NULL){
			flag.ptr = p;
			flag.temp = 1;//标记为1表示第一次入栈
			//将flag压入栈
			s.push(flag);
			//访问左孩子
			p = p->left_Child;
		}
		else{
			//出栈
			flag = s.top();
			s.pop();
			//将p指向当前需要处理的结点
			p = flag.ptr;
			//判断入栈次数，若为1，则表明只访问过左子树，还需继续访问右子树
			if (flag.temp == 1){
				//将temp改为2，即指将要进行第二系入栈
				flag.temp = 2;
				s.push(flag);
				//访问右孩子
				p = p->right_Child;
			}
			//若temp=2则表示左右子树均已被访问
			else{
				//输出结点数据域
				cout << p->data << " ";
				//令p为空，以保证下一次循环时会出栈
				p = NULL;
			}
		}
	}
}

//主函数
int main(){
	//创建一棵树
	BiTree *tree = new BiTree();
	cout << "经前序遍历后的结果为：";
	tree->preOrderTraverse(tree->root);
	cout << "\n";
	cout << "经中序遍历后的结果为：";
	tree->inOrderTraverse(tree->root);
	cout << "\n";
	cout << "经后序遍历后的结果为：";
	tree->postOrderTraverse(tree->root);
	cout << "\n";
	cout << "经非递归前序遍历后的结果为：";
	tree->unDiGuiPreOrderTraverse(tree->root);
	cout << "\n";
	cout << "经非递归中序遍历后的结果为：";
	tree->unDiGuiInOrderTraverse(tree->root);
	cout << "\n";
	cout << "经非递归后序遍历后的结果为：";
	tree->unDiGuiPostOrderTraverse(tree->root);
	cout << "\n";
	return 0;
}

运行结果：

！！！希望以上对大家有帮助！！
不要忘了给点个赞哈哈！！！