二叉线索树的线索化以及遍历

//二叉树的创建，递归遍历，非递归遍历，拷贝，深度
#include<iostream>
#include<stack>
using namespace std;
二叉树的结构
//typedef struct BiTNode
//{
//	char data;//数据域
//	int LTag = 0;//左标签
//	int RTag = 0;//右标签
//	struct BiTNode* lchild = nullptr;//指针必须初始化，c11标准
//	struct BiTNode* rchild = nullptr;//左右孩子
//	struct BiTNode* parent = nullptr;//双亲
//}BiTNode, * BiTree;
二叉树的结构
//二叉树的结构
typedef struct BiTNode
{
	char data;//数据域
	int LTag = 0;//左标签
	int RTag = 0;//右标签
	struct BiTNode* lchild = nullptr;//指针必须初始化，c11标准
	struct BiTNode* rchild = nullptr;//左右孩子
	struct BiTNode* parent = nullptr;//双亲
}BiTNode, * BiTree;
//二叉树的结构
BiTree pre;//= new BiTNode;//全局变量
BiTree parent = NULL;
//二叉树的创建
void CreateBiTree(BiTree& T,BiTree P)//先序输入 
{
	char ch;
	cin >> ch;
	if (ch == '#') T = NULL;
	else
	{
		T = new BiTNode;//分配空间
		T->data = ch;//根节点赋值
		T->parent = P;
		CreateBiTree(T->lchild,T);//建立左子树
		CreateBiTree(T->rchild,T);//建立右子树
	}
}
//二叉树的创建

//复制树
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);
}
//节点数量

//以结点T为根的子树先序线索化
void PreThreading(BiTree& T)
{
	if (T)//T非空
	{
		if (!T->lchild)//左子树为空
		{
			T->LTag = 1;
			T->lchild = pre;
		}
		else
		{
			T->LTag = 0;
		}
		if (!pre->rchild)
		{
			pre->RTag = 1;
			pre->rchild = T;
		}
		else
		{
			T->RTag = 0;
		}
		pre = T;
		if (T->LTag == 0)
		{
			PreThreading(T->lchild);//遍历左子树
		}
		if (T->RTag == 0)
		{
			PreThreading(T->rchild);//遍历右子树
		}
	}
}
//以结点T为根的字树先序线索化

//带头节点的二叉树先序线索化
void PreOrderThreading(BiTree& Thrt, BiTree T)
{
	Thrt = new BiTNode;
	Thrt->LTag = 0;
	Thrt->RTag = 1;
	Thrt->rchild = Thrt;
	if (!T)
	{
		Thrt->lchild = Thrt;
	}
	else
	{
		Thrt->lchild = T;
		pre = Thrt;
		PreThreading(T);
		pre->rchild = Thrt;
		pre->RTag = 1;
		Thrt->rchild = pre;
	}
}
//带头节点的二叉树先序线索化

//遍历先序线索二叉树
void PreTraverse_Thr(BiTree T)
{
	BiTree p = T->lchild;
	while (p != T)
	{
		cout << p->data;
		if (p->LTag == 0)
		{
			p = p->lchild;
		}
		else
		{
			p = p->rchild;
		}
	}
}
//遍历先序线索二叉树

//以结点T为根的子树中序线索化
void InThreading(BiTree &T)
{
	if (T)//T非空
	{
		InThreading(T->lchild);//遍历左子树
		if (!T->lchild)//左子树为空
		{
			T->LTag = 1;
			T->lchild = pre;
		}
		else
		{
			T->LTag = 0;
		}
		if (!pre->rchild)
		{
			pre->RTag = 1;
			pre->rchild = T;
		}
		else
		{
			T->RTag = 0;
		}
		pre = T;
		InThreading(T->rchild);
	}
}
//以结点T为根的字树中序线索化

//带头节点的二叉树中序线索化
void InOrderThreading(BiTree& Thrt, BiTree T)
{
	Thrt = new BiTNode;
	Thrt->LTag = 0;
	Thrt->RTag = 1;
	Thrt->rchild = Thrt;
	if (!T)
	{
		Thrt->lchild = Thrt;
	}
	else
	{
		Thrt->lchild = T;
		pre = Thrt;
		InThreading(T);
		pre->rchild = Thrt;
		pre->RTag = 1;
		Thrt->rchild = pre;
	}
}
//带头节点的二叉树中序线索化

//遍历中序线索二叉树
void InTraverse_Thr(BiTree T)
{
	BiTree p = T->lchild;//
	while (p != T)
	{
		while (p->LTag == 0)
		{
			p = p->lchild;
		}
		cout << p->data;
		while (p->RTag == 1 && p->rchild != T)
		{
			p = p->rchild;
			cout << p->data;
		}
		p = p->rchild;
	}
}
//遍历中序线索二叉树

//以结点T为根的子树后序线索化
void PosThreading(BiTree& T)
{
	if (T)//T非空
	{
		PosThreading(T->lchild);//遍历左子树
		PosThreading(T->rchild);//遍历右子树
		if (!T->lchild)//左子树为空
		{
			T->LTag = 1;
			T->lchild = pre;
		}
		else
		{
			T->LTag = 0;
		}
		if (!pre->rchild)
		{
			pre->RTag = 1;
			pre->rchild = T;
		}
		else
		{
			T->RTag = 0;
		}
		pre = T;
	}
}
//以结点T为根的字树后序线索化

//带头节点的二叉树后序线索化
void PosOrderThreading(BiTree& Thrt, BiTree T)
{
	Thrt = new BiTNode;
	Thrt->LTag = 0;
	Thrt->RTag = 1;
	Thrt->rchild = T;
	if (!T)
	{
		Thrt->lchild = Thrt;
	}
	else
	{
		Thrt->lchild = T;
		pre = Thrt; 
		PosThreading(T);
	}
}
//带头节点的二叉树后序线索化

//遍历后序线索二叉树
//后序遍历需要双亲节点
void PosTraverse_Thr(BiTree T)
{
	BiTree root = T->lchild;//初始节点
	BiTree prev = nullptr;//记录上一个节点
	while (root)
	{
		if (root->lchild == root->rchild)//如果双亲没有左子树或者右子树
		{
			root = root->rchild;
		}
		while (root->LTag == 0 && root->lchild != prev)//找到最左边的节点
		{
			root = root->lchild;
		}
		while (root->RTag == 1)//输出并遍历节点的后继
		{
			cout << root->data;
			prev = root;//记录上一个节点
			root = root->rchild;
		}
		if (root == T->lchild)//判断是不是根节点
		{
			cout << root->data;
			return;
		}
		while (root->rchild == prev)//不是根节点，访问当前节点的双亲节点
		{
			cout << root->data;
			prev = root;
			root = root->parent;
			if (root == nullptr)//遍历到根节点，退出
			{
				return;
			}
		}
		if (root->RTag == 0)//遍历右子树
		{
			root = root->rchild;
		}
	}
}
//遍历后序线索二叉树

int main()
{
	BiTree T;
	BiTree P = nullptr;
	BiTree Thrt;
	cout << "树的先序遍历为：";
	CreateBiTree(T,P);
	InOrderThreading(Thrt, T);
	InTraverse_Thr(Thrt);
	/*cout << endl;
	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;
}