树的遍历

//二叉树的创建，递归遍历，非递归遍历，拷贝，深度
#include<iostream>
#include<stack>
using namespace std;

//二叉树的结构
typedef struct BiTNode
{
	char data;//数据域
	struct BiTNode *lchild = nullptr;//指针必须初始化，c11标准
	struct BiTNode *rchild = nullptr;//左右孩子
}BiTNode,*BiTree;
//二叉树的结构

//二叉树的创建
void CreateBiTree(BiTree& T)//先序输入 
{
	char ch;
	cin >> ch;
	if (ch == '#') T = NULL;
	else
	{
		T = new BiTNode;//分配空间
		T->data = ch;//根节点赋值
		CreateBiTree(T->lchild);//建立左子树
		CreateBiTree(T->rchild);//建立右子树
	}
}
//二叉树的创建

//先序遍历
void PreTraverse(BiTree T)
{
	if (T)
	{
		cout << T->data;
		PreTraverse(T->lchild);
		PreTraverse(T->rchild);
	}
}
//先序遍历

//中序遍历
void InTraverse(BiTree T)
{
	if (T)
	{
		InTraverse(T->lchild);
		cout << T->data;
		InTraverse(T->rchild);
	}
}
//中序遍历

//后序遍历
void PosTraverse(BiTree T)
{
	if (T)
	{
		PosTraverse(T->lchild);
		PosTraverse(T->rchild);
		cout << T->data;
	}
}
//后序遍历

// 非递归中序遍历
void NoInTraverse(BiTree T)
{
	stack<BiTree> S;//栈
	BiTree p = T;//p指向T
	BiTree q = new BiTNode;
	while (p || !S.empty())
	{
		if (p)
		{
			S.push(p);//进栈
			p = p->lchild;//遍历左子树
		}
		else
		{
			q = S.top();
			cout << q->data;//输出栈顶元素,即输出根节点
			S.pop();
			p = q->rchild;//遍历右子树
		}
	}
} 
//非递归中序遍历

// 非递归先序遍历
void NoPreTraverse(BiTree T)
{
	stack<BiTree> S;//栈
	BiTree p = T;//p指向T
	BiTree q = new BiTNode;
	while (p || !S.empty())
	{
		if (p)
		{
			cout << p->data;//输出根节点
			S.push(p);//入栈
			p = p->lchild;//遍历左子树
		}
		else
		{
			q = S.top();//获取根节点
			S.pop();
			p = q->rchild;//遍历右子树
		}
	}
}
//非递归先序遍历

// 非递归后序遍历
void NoPosTraverse(BiTree T)//先根右左，再把栈反转
{
	stack<BiTree> S;//栈
	stack<BiTree> Stack;
	BiTree p = T;//p指向T
	BiTree q = new BiTNode;
	while (p || !S.empty())
	{
		if (p)
		{
			//cout << p->data;//输出根节点
			S.push(p);//入栈
			Stack.push(p);
			p = p->rchild;//遍历左子树
		}
		else
		{
			q = S.top();//获取根节点
			S.pop();
			p = q->lchild;//遍历右子树
		}
	}
	while (!Stack.empty())
	{
		cout << Stack.top()->data;
		Stack.pop();
	}
}
//非递归后序遍历

//复制树
void Copy(BiTree T ,BiTree& NewT)
{
	if (T == NULL)
	{
		NewT = NULL;
		return;
	}
	else
	{
		NewT = new BiTNode;
		NewT->data = T->data;
		Copy(NewT->lchild, T->lchild);
		Copy(NewT->rchild, T->rchild);
	}
}
//复制树

//计算树的深度
int Depth(BiTree T)
{
	if (T == NULL) return 0;
	else
	{
		int m = Depth(T->lchild);
		int n = Depth(T->rchild);
		if (m > n) return (m + 1);
		else return (n + 1);
	}
	return 0;
}
//计算树的深度

//节点数量
int NodeCount(BiTree T)
{
	if (T == NULL) return 0;
	else return (NodeCount(T->lchild) + NodeCount(T->rchild) + 1);
}
//节点数量
int main()
{
	BiTree T ;
	cout << "树的先序遍历为：";
	CreateBiTree(T);
	cout << "前序遍历：";
	PreTraverse(T);
	cout << endl;
	cout << "中序遍历：";
	InTraverse(T);
	cout << endl;
	cout << "后序遍历：";
	PosTraverse(T);
	cout << endl;
	cout << "先序遍历的非递归算法为：";
	NoPreTraverse(T);
	cout << endl;
	cout << "中序遍历的非递归算法为：";
	NoInTraverse(T);
	cout << endl;
	cout << "后序遍历的非递归算法为：";
	NoPosTraverse(T);
	cout << endl;
	cout << "树的深度为：" << Depth(T) << endl;
	cout << "树的节点个数为：" << NodeCount(T) << endl;
	cout << "树的叶结点个数为：" << NodeCount(T) << endl;
	return 0;
}