数据结构线索化二叉树（C语言）

先序线索化

#define ElemType int
#define NULL 0

//全局变量pre，指向当前访问结点的前驱
ThreadNode* pre = NULL;

//先序线索化二叉树T
void CreatPreThread(ThreadTree T) {
	pre = NULL;
	if (T != NULL) {
		PreThread(T);        //先序线索化二叉树
		if (pre->rchild == NULL)
			pre->rtag == 1;    //处理遍历的最后一个结点
	}
}


//线索二叉树结点
typedef struct ThreadNode {
	ElemType data;
	struct ThreadNode* lchild, * rchild;
	int ltag, rtag;        //左右线索标志
}ThreadNode, * ThreadTree;


//先序遍历二叉树，一边遍历一边线索化
void PreThread(ThreadTree T) {
	if (T != NULL) {
		visit(T);                    //访问根节点
		if(T->ltag==0)               //lchild不是前驱线索
			PreThread(T->lchild);    //先序遍历左子树
		PreThread(T->rchild);        //先序遍历右子树
	}
}

void visit(ThreadNode* q) {
	if (q->lchild == NULL) {    //左子树为空，建立前驱线索
		q->lchild = pre;
		q->ltag = 1;
	}
	if (pre != NULL && pre->rchild == NULL) {
		pre->rchild = q;        //建立前驱节点的后继线索
		pre->rtag = 1;
	}
	pre = q;
}

中序线索化

#define ElemType int
#define NULL 0

//全局变量pre，指向当前访问结点的前驱
ThreadNode* pre = NULL;

//中序线索化二叉树T
void CreatInThread(ThreadTree T) {
	pre = NULL;
	if (T != NULL) {
		InThread(T);        //中序线索化二叉树
		if (pre->rchild == NULL)
			pre->rtag == 1;    //处理遍历的最后一个结点
	}
}


//线索二叉树结点
typedef struct ThreadNode {
	ElemType data;
	struct ThreadNode* lchild, * rchild;
	int ltag, rtag;        //左右线索标志
}ThreadNode, * ThreadTree;


//中序遍历二叉树，一边遍历一边线索化
void InThread(ThreadTree T) {
	if (T != NULL) {
		InThread(T->lchild);    //中序遍历左子树
		visit(T);               //访问根节点
		InThread(T->rchild);    //中序遍历右子树
	}
}


void visit(ThreadNode* q) {
	if (q->lchild == NULL) {    //左子树为空，建立前驱线索
		q->lchild = pre;        
		q->ltag = 1;
	}
	if (pre != NULL && pre->rchild == NULL) {
		pre->rchild = q;        //建立前驱节点的后继线索
		pre->rtag = 1;
	}
	pre = q;
}

//中序线索二叉树找中序后继
//ThreadNode* Firstnode(ThreadNode* p);
//ThreadNode* Nextnode(ThreadNode* p);

//找到以p为根的子树中，第一个被中序遍历的结点
ThreadNode* Firstnode(ThreadNode* p) {
	//循环找到最左下结点（不一定是叶结点）
	while (p->ltag == 0) p = p->lchild;
	return p;
}

//在中序线索二叉树中找到结点p的后继结点
ThreadNode* Nextnode(ThreadNode* p) {
	//右子树中最左下结点
	if (p->rtag == 0) return Firstnode(p->rchild);  //p->rtag==0表示p结点有右孩子
	else return p->rchild;
}

//对中序线索二叉树进行中序遍历（利用线索实现的非递归算法）
void Inorder(ThreadNode* T) {
	for (ThreadNode* p = Firstnode(T); p != NULL; p = Nextnode(p))
		visit(p);
}

//中序线索二叉树找中序前驱
//ThreadNode* Lastnode(ThreadNode* p);
//ThreadNode* Nextnode(ThreadNode* p);

//找到以p为根的子树中，第一个被中序遍历的结点
ThreadNode* Lastnode(ThreadNode* p) {
	//循环找到最右下结点（不一定是叶结点）
	while (p->rtag == 0) p = p->rchild;
	return p;
}

//在中序线索二叉树中找到结点p的前驱结点
ThreadNode* Prenode(ThreadNode* p) {
	//左子树中最右下结点
	if (p->ltag == 0) return Lastnode(p->lchild);  //p->ltag==0表示p结点有左孩子
	else return p->lchild;
}

//对中序线索二叉树进行逆向中序遍历
void RevInorder(ThreadNode* T) {
	for (ThreadNode* p = Lastnode(T); p != NULL; p = Prenode(p))
		visit(p);
}

后序线索化

#define ElemType int
#define NULL 0

//全局变量pre，指向当前访问结点的前驱
ThreadNode* pre = NULL;

//后序线索化二叉树T
void CreatPostThread(ThreadTree T) {
	pre = NULL;
	if (T != NULL) {
		PostThread(T);        //后序线索化二叉树
		if (pre->rchild == NULL)
			pre->rtag == 1;    //处理遍历的最后一个结点
	}
}


//线索二叉树结点
typedef struct ThreadNode {
	ElemType data;
	struct ThreadNode* lchild, * rchild;
	int ltag, rtag;        //左右线索标志
}ThreadNode, * ThreadTree;


//中序遍历二叉树，一边遍历一边线索化
void PostThread(ThreadTree T) {
	if (T != NULL) {
		PostThread(T->lchild);    //后序遍历左子树
		PostThread(T->rchild);    //后序遍历右子树
		visit(T);               //访问根节点
	}
}

void visit(ThreadNode* q) {
	if (q->lchild == NULL) {    //左子树为空，建立前驱线索
		q->lchild = pre;
		q->ltag = 1;
	}
	if (pre != NULL && pre->rchild == NULL) {
		pre->rchild = q;        //建立前驱节点的后继线索
		pre->rtag = 1;
	}
	pre = q;
}