#include <string>
#include <iostream>
#include <vector>
using namespace std;

typedef enum {Link, Thread} PointerTag;            /* Link==0表示指向左右孩子指针, */
										           /* Thread==1表示指向前驱或后继的线索 */
typedef struct BitNode
{
	char data;                                     /* 结点数据 */                 
	BitNode *lchild, *rchild;                      /* 左右孩子指针 */
	PointerTag LTag;
	PointerTag RTag;                               /* 左右标志 */

}*PBitNode;


void CreateBiTree(PBitNode &T);
void InOrderThreading(PBitNode &T, PBitNode &H);
void InThreading(PBitNode &T);
void InOrderTraverse(PBitNode T);


/* 按前序输入构造二叉树T */
void CreateBiTree(PBitNode &T)                    //必须传递引用
{
	char ch;
	cin >> ch;
	if (ch == '#')
		T = NULL;
	else
	{
		T = (BitNode*)malloc(sizeof(BitNode));
		if (!T)
			exit(OVERFLOW);
		(T)->data = ch;                        /* 生成根结点(前序) */
		CreateBiTree(T->lchild);               /* 递归构造左子树 */
		if (T->lchild)
			T->LTag = Link;
		CreateBiTree(T->rchild);               /* 递归构造右子树 */
		if (T->rchild)
			T->RTag = Link;
	}
}

PBitNode pre = (PBitNode)malloc(sizeof(BitNode));
/* 中序遍历进行中序线索化 */
void InThreading(PBitNode &T)
{
	if (T)
	{
		InThreading(T->lchild);                /* 递归左子树线索化 */
		if (!T->lchild)                        /* 没有左孩子 */
		{
			T->LTag = Thread;                  /* 前驱线索 */
			T->lchild = pre;                   /* 左孩子指针指向前驱 */
		}
		if (!pre->rchild)
		{
			pre->RTag = Thread;
			pre->rchild = T;                   /* 前驱右孩子指针指向后继(当前结点p) */
		}
		pre = T;                               /* 保持pre指向p的前驱 */
		InThreading(T->rchild);                /* 递归右子树线索化 */
	}
		

}

/* 中序遍历二叉树T,并将其中序线索化 */
void InOrderThreading(PBitNode &T, PBitNode &H)
{
//此子函数初始化方式详见上图 H为图中头指针
	H = (PBitNode)malloc(sizeof(BitNode));
	H->LTag = Link;
	H->RTag = Thread;
	H->lchild = T;
	H->rchild = H;
	pre = H;
	InThreading(T);                     /* 中序遍历进行中序线索化 */
	pre->rchild = H;                    /* 最后一个结点线索化 */
	pre->RTag = Thread;
	H->rchild = pre;
}




/* 中序遍历二叉线索树T(头结点)的非递归算法 */
void InOrderTraverse(PBitNode H)
{
	PBitNode P = H->lchild;
	while (P != H)
	{
		while (P->LTag == Link)
			P = P->lchild;
		cout << P->data << endl;
		while (P->RTag == Thread & P->rchild != H)
		{
			P = P->rchild;
			cout << P->data << endl;
		}
		P = P->rchild;
	}
}

//递归前序遍历二叉树
void PreOrderTraverse(PBitNode T)
{
	if (T == NULL)
		return;
	cout << T->data << endl;
	PreOrderTraverse(T->lchild);
	PreOrderTraverse(T->rchild);
}




int main()
{
	PBitNode Tree, Head;
	
	CreateBiTree(Tree);									//构造二叉树
	cout << "Creation's done" << endl;
	PreOrderTraverse(Tree);								//中序遍历二叉树
	cout << "PreOrderTraverse's done" << endl;
	InOrderThreading(Tree, Head);						//线索化二叉树
	cout << "InOrderThreading's done" << endl;
	InOrderTraverse(Head);								//线索遍历
	cout << "InOrderTraverse's done" << endl;
	getchar();
	getchar();
	return 0;
}