数据结构之线索二叉树

思维导图：

线索二叉数的引入：

先来看这样几个问题：
1、普通二叉树只有指向孩子节点的指针而没有指向双亲节点的指针，这样就会产生一个问题，无法方便快速的找到某一节点的双亲节点
2、当我们不知道根节点的指针，而是知道某一节点(非根节点)指针，就无法对二叉树进行遍历

我们知道，用链式存储二叉树时，会产生n+1个空指针，我们是否可以利用这些空指针而很方便的实现上述的两种操作呢？
为此，我们引入线索二叉树的概念。

线索二叉树：

在实现一颗二叉树时，会产生空指针，个数为n+1个，若节点无左子树，将指针指向前驱节点；若无右子树，将指针指向后继节点，从而实现线索化，将加上线索的二叉树称为线索二叉树。即：
1、若无左子树，将指针指向前驱节点
2、若无右子树，将指针指向后继节点

前序遍历的线索二叉树：

ps： 由遍历序列得到图

中序遍历的线索二叉树（常）：

后序遍历的线索二叉树：

线索二叉树的节点结构：

例如：

typedef struct ThreadNode{
	int data;
	struct ThreadNode *lchild,*rchild;
	int ltag,rtag;
}ThreadNode , *ThreadTree;

中序线索二叉树代码实现

中序线索二叉树的构造：

原理：

找前驱节点：
若左指针为线索，则其指向节点为前驱节点
若左指针为左孩子，则其左子树的最右侧节点为前驱节点
找后继节点：
若右指针为线索，则其指向节点为后继节点
若右指针为右孩子，则其右子树的最左侧节点为后继节点

代码实现：

void InThread(ThreadTree &p){
	if(p != NULL){
		InThread(p->lchild);
		visit(T);
		InThread(p->rchild);
	}
} 

void visit(ThreadNode *p){
		if(p->lchild == NULL){
			p->lchild = pre;
			p->ltag = 1;
		}
		if(pre != NULL && pre->rchild == NULL){
			pre->rchild = p;
			pre->rtag = 1;
		}
		pre = p;
}

void CreateInThread(ThreadTree T){
	ThreadTree pre = NULL;
	if(T != NULL){
		InThread(T,pre);
		if(pre->rchild == NULL)
			pre->rtag = 1;
	}
}

中序线索二叉树的遍历以及找节点p的后序节点：

1、找到以p为根的子树中，第一个被中序遍历的节点
2、在中序线索二叉树中找到节点p的后继节点
3、实现对二叉树的中序遍历

//找到以p为根的子树中，第一个被中序遍历的节点
ThreadNode *Fristnode(ThreadNode *p){
	//循环找到最左下节点，不一定是叶节点
	while(p->ltag == 0)
		p = p->lchild;
	return p;
}
//在中序线索二叉树中找到节点p的后继节点
ThreadNode *Nextnode(ThreadNode *p){
	if(p->rtag == 0)
		return Firstnode(p->rchild);
	else
		return p->rchild;
}
//上面两个函数实现了找到指定节点p的中序后继，下面的函数实现对二叉树的中序遍历
//利用线索实现的恶非递归算法，空间复杂的o(1)
void Inorder(ThreadNode *T){
	for(ThreadNode *p = Firstnode(T);p != NULL;p = Nextnode(p))
		visit(p);
}

中序线索二叉树的逆遍历以及找节点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 Lasttnode(p->lchild);
	else
		return p->lchild;
}
//上面两个函数实现了找到指定节点p的中序后继，下面的函数实现对二叉树的逆中序遍历
//利用线索实现的恶非递归算法，空间复杂的o(1)
void Revorder(ThreadNode *T){
	for(ThreadNode *p = Lastnode(T);p != NULL;p = Prenode(p))
		visit(p);
}

先序线索二叉树代码实现

先序线索二叉树的构造：

代码实现：

void PreThread(ThreadTree &p){
	if(p != NULL){
		visit(p);
		//当处理完p节点后会访问p->lchild,但是经过visit(P)后p->lchild就会指向p的前驱节点，所以要对其进行判断
		if(T->ltag == 0)				//lchild不是前驱线索		
			PreThread(p->lchild);
			PreThread(p->rchild);
	}
} 

void visit(ThreadNode *p){
		if(p->lchild == NULL){
			p->lchild = pre;
			p->ltag = 1;
		}
		if(pre != NULL && pre->rchild == NULL){
			pre->rchild = p;
			pre->rtag = 1;
		}
		pre = p;
}

void CreateInThread(ThreadTree T){
	ThreadTree pre = NULL;
	if(T != NULL){
		InThread(T,pre);
		if(pre->rchild == NULL)
			pre->rtag = 1;
	}
}

先序线索二叉树的遍历以及找节点p的后序节点：

先序线索二叉树的逆遍历以及找节点p的前驱节点：

ps:在只有指向孩子节点的节点结构中无法找到前驱
解决：增加一个指向双亲节点的指针

后序线索二叉树代码实现

后序线索二叉树的构造：

代码实现：

void PostThread(ThreadTree &p){
	if(p != NULL){
		PostThread(p->lchild);
		PostThread(p->rchild);
		visit(T);
	}
} 

void visit(ThreadNode *p){
		if(p->lchild == NULL){
			p->lchild = pre;
			p->ltag = 1;
		}
		if(pre != NULL && pre->rchild == NULL){
			pre->rchild = p;
			pre->rtag = 1;
		}
		pre = p;
}

void CreateInThread(ThreadTree T){
	ThreadTree pre = NULL;
	if(T != NULL){
		InThread(T,pre);
		if(pre->rchild == NULL)
			pre->rtag = 1;
	}
}

后序线索二叉树的遍历以及找节点p的后序节点：

后序线索二叉树的遍历以及找节点p的前驱节点：

ps:在只有指向孩子节点的节点结构中无法找到前驱
解决：增加一个指向双亲节点的指针

总结：