数据结构：线索二叉树怎么找到前驱和后继，如何遍历输出？

上一篇博客介绍了线索二叉树的构造，以及简单的递归输出方法

https://blog.csdn.net/hpu2022/article/details/107234190

阅读本文可以先大致了解一下上一篇文章

线索二叉树定义

typedef struct ThreadNode{
    ElemType data;
    // 前驱线索->左孩子、后继线索->右孩子  
    struct ThreadNode *lchild, *rchild; 
    // tag为0表示孩子，tag为1表示线索 
	int ltag, rtag;
} ThreadNode, *ThreadTree;

上一篇中遍历输出方法，此种方法是我当时自己想的低数据量时没有问题，不能确定数据多的时候是否正确

// 中序遍历 当线索化完成后中序遍历会出现转圈圈问题
// 具体解决方法是 在递归遍历过程用tag == 0？来判断是否为当前结点的孩子 
void InOrder(ThreadTree T)
{

	if(NULL != T){
		if(0 == T->ltag)
			InOrder(T->lchild); // 递归遍历左子树 
		PrintNode(T);			// 访问根节点 
		if(0 == T->rtag) 
			InOrder(T->rchild); // 递归遍历右子树 
	} 
}

// 打印结点信息 
void PrintNode(ThreadNode *node)
{
	if(NULL == node->lchild){
		printf("前驱：NULL  ");
	}
	else{
		printf("前驱：%d  ", node->lchild->data);
	}
	printf("自己：%d  ", node->data);
	if(NULL == node->rchild){
		printf("后继：NULL\n");	
	}
	else{
		printf("后继：%d\n", node->rchild->data);
	}
}

下面这种方法是更为科学的一种方法，是王道408系列课程给出的方法。详细看注释

找后继结点

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

// 中序线索二叉树中找到结点p的后继结点 
ThreadNode *NextNode(ThreadNode *p) 
{
	if(0 == p->rtag){
		// 返回右子树中的最左下结点 
		return FirstNode(p->rchild);
	}
	else{
		return p->rchild; // rtag == 1 直接返回后继线索 
	}
}

// 对中序线索二叉树进行中序遍历（非递归算法） 
void InOrder(ThreadNode *T) 
{
	for(ThreadNode *p = FirstNode(T); p != NULL; p = NextNode(p)){
		PrintNode(p);
	}
}

找前驱结点

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

// 在中序线索二叉树中找到p的前驱 
ThreadNode* PreNode(ThreadNode *p)
{ 
	if(p->ltag == 0){
		// 返回左子树中最右下结点 
		return LastNode(p->lchild);
	}
	else{
		return p->lchild;
	}
}

// 对线索二叉树逆向中序遍历 
void RevInOrder(ThreadNode *T)
{
	for(ThreadNode *p = LastNode(T); p != NULL; p = PreNode(p)){
		PrintNode(p);
	}
}

code:

#include 
#include 

#define ElemType int

typedef struct ThreadNode{
    ElemType data;
    // 前驱线索->左孩子、后继线索->右孩子  
    struct ThreadNode *lchild, *rchild; 
    // tag为0表示孩子，tag为1表示线索 
	int ltag, rtag;
} ThreadNode, *ThreadTree;

ThreadNode *preNode = NULL; // 全局变量，用来记录当前结点的前驱结点 

// 线索化处理每一个结点 
void visit(ThreadNode *nowNode)
{
	if(NULL == nowNode->lchild){ // 当前结点的前驱为空，为他建立前驱线索 
		nowNode->lchild = preNode;
		nowNode->ltag = 1;
	}
	 
	if(NULL != preNode && NULL == preNode->rchild){ // 为前驱结点建立后继线索 
		preNode->rchild = nowNode;
		preNode->rtag = 1;
	}
	preNode = nowNode; // 后移，以便访问下一个结点 
}

// 线索二叉树初始化 
void InitThreadTree(ThreadTree &T)
{
	T == NULL;
}

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

// 建立二叉树结点并返回结点地址 
ThreadNode* CreateNode(int data)
{
	struct ThreadNode *node = (ThreadNode *)malloc(sizeof(ThreadNode));
	node->ltag = 0;
	node->rtag = 0;
	node->lchild = NULL;
	node->rchild = NULL;	
	node->data = data; 
	return node;
}

// 建立二叉树
void CreateBiTree(ThreadTree &T) 
{
	// 手动建立一个简单的二叉树 
	T = CreateNode(1);
	T->lchild = CreateNode(2);
	T->rchild = CreateNode(3);
	T->lchild->lchild = CreateNode(4);
	T->rchild->lchild = CreateNode(5);
}


// 建立中序线索二叉树
void CreateInThread(ThreadTree T)
{
	preNode = NULL;
	if(NULL != T){
		InThread(T); // 这一行是哪种遍历方式就是哪种线索化方式 
		if(NULL == preNode->rchild){ // 遍历到的最后一个结点线索化 
			preNode->rtag = 1;
		}
	}
}

// 打印结点信息 
void PrintNode(ThreadNode *node)
{
	if(NULL == node->lchild){
		printf("前驱：NULL  ");
	}
	else{
		printf("前驱：%d  ", node->lchild->data);
	}
	printf("自己：%d  ", node->data);
	if(NULL == node->rchild){
		printf("后继：NULL\n");	
	}
	else{
		printf("后继：%d\n", node->rchild->data);
	}
}

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

// 中序线索二叉树中找到结点p的后继结点 
ThreadNode *NextNode(ThreadNode *p) 
{
	if(0 == p->rtag){
		// 返回右子树中的最左下结点 
		return FirstNode(p->rchild);
	}
	else{
		return p->rchild; // rtag == 1 直接返回后继线索 
	}
}

// 对中序线索二叉树进行中序遍历（非递归算法） 
void InOrder(ThreadNode *T) 
{
	for(ThreadNode *p = FirstNode(T); p != NULL; p = NextNode(p)){
		PrintNode(p);
	}
}

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

// 在中序线索二叉树中找到p的前驱 
ThreadNode* PreNode(ThreadNode *p)
{ 
	if(p->ltag == 0){
		// 返回左子树中最右下结点 
		return LastNode(p->lchild);
	}
	else{
		return p->lchild;
	}
}

// 对线索二叉树逆向中序遍历 
void RevInOrder(ThreadNode *T)
{
	for(ThreadNode *p = LastNode(T); p != NULL; p = PreNode(p)){
		PrintNode(p);
	}
}

int main()
{
	ThreadTree T;
	InitThreadTree(T); 
	CreateBiTree(T); // 建立二叉树 
	CreateInThread(T); // 建立线索二叉树 
	InOrder(T);	// 中序遍历输出 
	printf("\n");
	RevInOrder(T); 
	
    return 0;
}