【数据结构-树】线索二叉树

最新推荐文章于 2023-10-23 16:44:10 发布
最新推荐文章于 2023-10-23 16:44:10 发布
阅读量446 收藏 1
点赞数
分类专栏： # 数据结构与算法
本文章为作者原创，未经许可禁止转载。
本文链接：https://blog.csdn.net/baidu_39514357/article/details/126048648
版权

数据结构 算法

注：仅为本人做笔记用！如需更详细的介绍请参考其它博文。

文章目录

1 线索二叉树的存储结构

/* 1 线索二叉树的存储结构 */
typedef struct ThreadNode{
	ElemType data;						// 数据域 
	struct ThreadNode *lchild, *rchild;	// 左右指针域 
	int ltag, rtag;						// 左右线索标志：1 表示为线索 
}ThreadNode, *ThreadTree;

2 中序线索二叉树（LNR）

2.1 中序线索二叉树的构造

/* 2 中序线索二叉树 */
/* 2.1 中序线索二叉树的构造 */
// 用于构造线索二叉树的初始函数，T：待构造的树
void CreateInThread (ThreadNode T){		 
	ThreadTree pre = NULL;	// 用于记录
	if (T != NULL){
		InThread(T, pre);	// 中序线索化二叉树
		if (pre->rchild == NULL)	// 运行到此处时，一定只剩中序遍历的最后一个节点未线索化，因此需单独处理 
			pre->rtag = 1;
	} 
} 

// 思路：一边中序访问一边线索化，递归算法 
void InThread (ThreadTree &p, ThreadNode &pre){
	if (p != NULL){
		// step 1: 访问左子树/左结点，同时将其线索化 
		if (p->ltag == 0)
			InThread(p->lchild, pre);	
		// step 2: 访问根结点，同时将其线索化；此时 pre 为当前访问结点 p 的前驱结点 
		InVisit(p, pre)	
		// step 3: 访问右子树/右结点，同时将其线索化 
		if (p->rtag == 0)
			InThread(p->lchild, pre);	
	}
}

void InVisit (ThreadNode &p, ThreadNode &pre){
	// step 2.1: 如果发现当前访问结点 p 的左指针域为空，则使其指向前驱线索 pre 
	if (p->lchild == NULL){		 
		p->lchild = pre;		  
		p->ltag = 1;
	}	// 当前访问结点 p 的前驱线索建立完成 
	// step 2.2: 同时检查前驱结点 pre，如果前驱结点的右指针域为空，则使其指向当前访问结点 p
	if ((pre->rchild == NULL) && pre != NULL){  
		pre->child = p;
		pre->rtag = 1;
	}	// 前驱结点 pre 的后继线索建立完成 
	// step 2.3: 前驱结点 pre 往前遍历，指向当前访问结点 p 
	pre = p; 
}

2.2 中序线索二叉树的遍历

中序线索二叉树的遍历实质是找指定结点 p 的后继结点，其思路如下：

  • 若p->rtag == 1（即 p 无右孩子），则 p 的后继结点为p->rchild（即 p 的后继线索）；
  • 若p->rtag == 0（即 p 有右孩子），则 p 的后继结点为 p 的右子树的最左下的结点。
/* 2.2 中序线索二叉树的遍历 */
// 非递归算法 
// 该函数用于求 p 的右子树的最左下结点
ThreadNode *FirstNode (ThreadNode *p){
	// 如果是寻找中序遍历的第一个结点，则为整棵树的最左下结点，它不一定是叶结点 
	// 而对于指定结点 p，其后继结点为 p 的右子树的最左下的结点，它也不一定是叶结点 
	while (p->ltag == 0)
		p = p->lchild;
	return p;
} 

ThreadNode *NextNode (ThreadNode *p){
	if (p->rtag == 0) 
		return Firstnode(p->rchild);    // 找下一个后继结点 
	else 
		return p->rchild; // 指针域是后继线索，直接返回后继线索
}

void InOrder (ThreadNode &T){
	// 从中序遍历的第一个结点开始
	for (ThreadNode *p = FirstNode(T); p != NULL; p = NextNode(p))
		visit(p);
}

2.3 中序线索二叉树的逆遍历

中序线索二叉树的逆遍历实质是找指定结点 p 的前驱结点，其思路如下：

  • 若p->ltag == 1（即 p 无左孩子），则 p 的前驱结点为p->lchild（即 p 的前驱线索）；
  • 若p->ltag == 0（即 p 有左孩子），则 p 的前驱结点为 p 的左子树的最右下的结点。
/* 2.3 中序线索二叉树的逆遍历 */
// 非递归算法 
// 该函数用于求 p 的左子树的最右下结点
ThreadNode *LastNode (ThreadNode *p){
	// 如果是寻找中序逆遍历的第一个结点（即中序遍历的最后一个结点），则为整棵树的最右下结点，它不一定是叶结点 
	// 而对于指定结点 p，其前驱结点为 p 的左子树的最右下的结点，它也不一定是叶结点 
	while (p->rtag == 0)
		p = p->rchild;
	return p;
} 

ThreadNode *NextNode (ThreadNode *p){
	if (p->ltag == 0) 
		return Lastnode(p->lchild);	// 找上一个前驱结点 
	else 
		return p->lchild; // 指针域是前驱线索，直接返回前驱线索
}

void InReverse (ThreadNode &T){
	// 从中序遍历的最后一个结点开始
	for (ThreadNode *p = LastNode(T); p != NULL; p = NextNode(p))
		visit(p);
}

3 先序线索二叉树（NLR）

3.1 先序线索二叉树的构造

/* 3 先序线索二叉树 */
/* 3.1 先序线索二叉树的构造 */
// 用于构造线索二叉树的初始函数，T：待构造的树
void CreatePreThread (ThreadNode T){		 
	ThreadTree pre = NULL;	// 用于记录
	if (T != NULL){
		preThread(T, pre);	// 先序线索化二叉树
		if (pre->rchild == NULL)	// 运行到此处时，一定只剩先序遍历的最后一个节点未线索化，因此需单独处理 
			pre->rtag = 1;
	} 
} 

// 思路：一边先序访问一边线索化，递归算法 
void PreThread (ThreadTree &p, ThreadNode &pre){
	if (p != NULL){
		// step 1: 访问根结点，同时将其线索化；此时 pre 为当前访问结点 p 的前驱结点 
		PreVisit(p, pre)
		// step 2: 访问左子树/左结点，同时将其线索化，注意此处判断线索标志是必要的！ 
		if (p->ltag == 0)
			PreThread(p->lchild, pre);	
		// step 3: 访问右子树/右结点，同时将其线索化 
		if (p->rtag == 0)
			PreThread(p->rchild, pre);	
	}
}

void PreVisit (ThreadNode &p, ThreadNode &pre){
	// step 1.1: 如果发现当前访问结点 p 的左指针域为空，则使其指向前驱线索 pre 
	if (p->lchild == NULL){		 
		p->lchild = pre;		  
		p->ltag = 1;
	}	// 当前访问结点 p 的前驱线索建立完成 
	// step 1.2: 同时检查前驱结点 pre，如果前驱结点的右指针域为空，则使其指向当前访问结点 p
	if ((pre->rchild == NULL) && pre != NULL){  
		pre->child = p;
		pre->rtag = 1;
	}	// 前驱结点 pre 的后继线索建立完成 
	// step 1.3: 前驱结点 pre 往前遍历，指向当前访问结点 p 
	pre = p; 
}

3.2 先序线索二叉树的遍历

先序线索二叉树的遍历实质是找指定结点 p 的后继结点，其思路如下：

  • 若p->rtag == 1（即 p 无右孩子），则 p 的后继结点为p->lchild（即 p 的后继线索）；
  • 若p->rtag == 0（即 p 有右孩子）且p->ltag == 1（即 p 无左孩子），则 p 的后继结点为p->rchild（即 p 的右孩子）；
  • 若p->rtag == 0（即 p 有右孩子）且p->ltag == 0（即 p 有左孩子），则 p 的后继结点为p->lchild（即 p 的左孩子）。
/* 3.2 先序线索二叉树的遍历 */
ThreadNode *NextNode (ThreadNode *p){
	if (p->rtag == 1) 
		return p->lchild;	
	if ((p->rtag == 0) && (p->ltag == 1))
		return p->rchild; 
	if ((p->rtag == 0) && (p->ltag == 0))
		return p->lchild; 
}

void PreOrder (ThreadNode &T){
	// 从先序遍历的第一个结点开始
	for (ThreadNode *p = T; p != NULL; p = NextNode(p))
		visit(p);
}

3.3 先序线索二叉树的逆遍历（难实现）

先序线索二叉树的遍历实质是找指定结点 p 的前驱结点。

但是，因为先序遍历顺序是 NLR，而 p 的左右孩子都是后继结点，所以找不到 p 的前驱结点。因此，需要得知 p 的父节点，才能找到其前驱结点。

4 后序线索二叉树（LRN）

4.1 后序线索二叉树的构造

/* 4 后序线索二叉树 */
/* 4.1 后序线索二叉树的构造 */
// 用于构造线索二叉树的初始函数，T：待构造的树
void CreatePostThread (ThreadNode T){		 
	ThreadTree pre = NULL;	// 用于记录
	if (T != NULL){
		preThread(T, pre);	// 后序线索化二叉树
		if (pre->rchild == NULL)	// 运行到此处时，可能只剩后序遍历的最后一个节点（根结点）未线索化，因此需单独处理 
			pre->rtag = 1;
	} 
} 

// 思路：一边后序访问一边线索化，递归算法 
void PostThread (ThreadTree &p, ThreadNode &pre){
	if (p != NULL){
		// step 1: 访问左子树/左结点，同时将其线索化
		if (p->ltag == 0)
			PostThread(p->lchild, pre);	
		// step 2: 访问右子树/右结点，同时将其线索化 
		if (p->rtag == 0)
			PostThread(p->rchild, pre);	
		// step 3: 访问根结点，同时将其线索化；此时 pre 为当前访问结点 p 的前驱结点 
		PostVisit(p, pre)
	}
}

void PostVisit (ThreadNode &p, ThreadNode &pre){
	// step 3.1: 如果发现当前访问结点 p 的左指针域为空，则使其指向前驱线索 pre 
	if (p->lchild == NULL){		 
		p->lchild = pre;		  
		p->ltag = 1;
	}	// 当前访问结点 p 的前驱线索建立完成 
	// step 3.2: 同时检查前驱结点 pre，如果前驱结点的右指针域为空，则使其指向当前访问结点 p
	if ((pre->rchild == NULL) && pre != NULL){  
		pre->child = p;
		pre->rtag = 1;
	}	// 前驱结点 pre 的后继线索建立完成 
	// step 3.3: 前驱结点 pre 往前遍历，指向当前访问结点 p 
	pre = p; 
}

4.2 后序线索二叉树的遍历（难实现）

后序线索二叉树的遍历实质是找指定结点 p 的后继结点。

但是，因为后序遍历顺序是 LRN，而 p 的左右孩子都是前驱结点，所以找不到 p 的后继结点。因此，需要得知 p 的父节点，才能找到其后继结点。

4.3 后序线索二叉树的逆遍历

后序线索二叉树的逆遍历实质是找指定结点 p 的前驱结点，其思路如下：

  • 若p->ltag == 1（即 p 无左孩子），则 p 的后继结点为p->lchild（即 p 的前驱线索）；
  • 若p->ltag == 0（即 p 有左孩子）且p->rtag == 1（即 p 无右孩子），则 p 的后继结点为p->lchild（即 p 的左孩子）；
  • 若p->ltag == 0（即 p 有左孩子）且p->rtag == 0（即 p 有右孩子），则 p 的后继结点为p->rchild（即 p 的右孩子）。
/* 4.3 后序线索二叉树的逆遍历 */
ThreadNode *NextNode (ThreadNode *p){
	if (p->ltag == 1) 
		return p->rchild;	
	if ((p->ltag == 0) && (p->rtag == 1))
		return p->lchild; 
	if ((p->ltag == 0) && (p->rtag == 0))
		return p->rchild; 
}

void PostReverse (ThreadNode &T){
	// 从后序遍历的最后一个结点开始
	for (ThreadNode *p = T; p != NULL; p = NextNode(p))
		visit(p);
}
【数据结构】-树-先序线索二叉树，中序线索二叉树，后序线索二叉树
vector的博客
06-14 5498
先序线索二叉树，中序线索二叉树，后序线索二叉树之间的对比 结论： 1.先序线索二叉树找前驱节点困难，找后继节点简单 后序线索二叉树找后继节点困难，找前驱节点简单 中序线索二叉树找前驱节点，后继节点都很简单 2.遍历中序和先序线索二叉树，不需要栈，直接通过线索就可以实现 遍历后序线索二叉树，要用栈 注： 1.三种线索二叉树的叶子节点数都能通过线索直接找到前驱和后继，因此分析能否直接遍历，只需要看前非叶子节点是否能找到自己的前驱和后继就好了。 2.三种遍历前驱和后继的位置 ...
数据结构（十八） -- C语言版 -- 树 - 二叉树的线索化及遍历 -- 线索化后的直接前驱、后继获取
青椒*^_^*凤爪爪的博客
06-26 1万+
二叉树的线索化的目的就是为了方便二叉树节点的遍历和访问，那么既然要遍历，那么也就说明有顺序，也就是前后，但是既然提到了线索化，那么还是会很好奇线索化后某个节点的前驱节点、后继节点应该怎么取获取。那么本博文就带你了解。
【数据结构】-线索二叉树(中序)
RunningSnail的博客
08-09 1635
中序线索化二叉树1.头文件及类型定义2.线索二叉树结点类型定义3.函数声明4.基本操作4.1 先序建立线索二叉树4.2 初始化tag4.3 中序线索化二叉树4.3.1 访问并建立线索4.3.2 遍历4.3.3 中序线索化主过程4.4 寻找中序后继4.4.1 找到最左下结点4.4.2 找到p的后继结点4.4 寻找中序前驱4.4.1 找到最右下结点4.4.2 找到p的前驱4.5 中序遍历和逆向中序遍历4.5.1 打印结点4.5.2 利用中序后继实现中序遍历4.5.2 利用中序前驱实现逆向中序遍历4.6 main
线索二叉树
q322359的博客
10-08 429
线索二叉树
线索中序二叉树
CJMINGMING的博客
11-20 427
线索中序二叉树 1.节点的结构 typedef struct node { int lefttype;//左孩子类型，如果是普通左孩子则为Link，如果是前驱则为Thread int righttype;//右孩子类型，如果是普通右孩子则为Link，如果是后继则为Thread struct node* left; struct node* right; int d; }Node; 1.线索化算法 1.用一个pre指针指向访问当前节点p的前驱节点 2.在访问当前以p为
【数据结构】第6.3 树 线索二叉树
iivan_cpp的博客
01-21 799
目录
（十一）数据结构-线索二叉树
weixin_45579930的博客
08-01 4054
引入线索二叉树是为了查找结点前驱和后继的速度，知道了"前驱"、"后继"信息，就可以把二叉树看作一个链表结构，从而可以像遍历链表一样遍历二叉树。
数据结构-树和二叉树
小鸡仔快跑呀的博客
12-30 1046
数据结构-树和二叉树：树、二叉树、森林、二叉树的应用
数据结构-树与二叉树
qq_62063545的博客
04-30 209
1）二叉树是每个结点至多只有两棵子树的树，且二叉树存在左右之分，顺序不能任意颠倒，即使二叉树仅存在一个结点，也需要区分该结点的左右2）度为2的树至少有三个结点，但二叉树可以为空；度为2的树孩子的左右顺序是相对于另一个孩子而言的，当某个结点只有一个孩子时，也就不需要考虑孩子的左右顺序，但二叉树即使只有一个结点也需要考虑结点的左右顺序，即二叉树的左右顺序是绝对的，确定的3）满二叉树即指高h，结点数为2^h-1个的二叉树；完全二叉树即满二叉树少了最下层最右侧的部分叶结点的树；
数据结构（十七） -- C语言版 -- 树 - 二叉树的线索化及遍历 -- 先序线索化、中序线索化、后序线索化
热门推荐
青椒*^_^*凤爪爪的博客
06-20 2万+
在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。
数据结构-二叉树线索化及其实现05
FairLikeSnow的博客
02-16 695
二叉树线索化及其实现 1.为什么要有线索二叉树        为了解决无法直接找到该结点在某种遍历序列中的前驱和后继结点的问题我们在有n个结点的二叉链表中，每个结点有指向左右2个孩子的指针域，所以有2n个指针域，而n个结点的二叉树一共有n-1条分支线，也就是说，其实存在2n-(n-1) = n+1 个空指针域。空间十分浪费。 &...
数据结构——线索二叉树
q1060701529的博客
02-28 687
线索二叉树实际上就是对二叉树进行线性化。他把二叉树的没一个节点排列成一个线性序列。 二叉树节点创建
中序线索二叉树中必须牢记的概念
一只向入研坑的程序猿
03-10 258
中序线索二叉树中必须牢记的概念
数据结构—线索二叉树
m0_51769031的博客
06-08 423
无论哪一种序列线索化都不要忘记处理最后一个结点的rchild和rtag；注意先序线索化的死循环问题，当ltag==0的时候才能对左子树先序线索化。 1.2 中序线索二叉树的构造 2、先序线索化 特别注意在先序线索化的过程中，当访问完根节点开始访问其左子树的时候，要判断其左孩子是不是前驱线索，避免出现死循环。 4、中序线索二叉树寻找中序后继 对不含头结点的中序线索二叉树的遍历： 5、中序线索二叉树中寻找中序前驱结点 对不含头结点的线索二叉树逆序遍
二叉树的链式存储结构（线索二叉树）
qq_44111805的博客
02-28 6874
一、链式存储结构 由于顺序存储二叉树的空间利用率较低，因此二叉树一般都采用链式存储结构，用链表结点来存储二叉树中的每个结点。在二叉树中，结点结构通过包括若干数据域和若干指针域，二叉链表至少包含3个域：数据域 data、左指针域 lchild和右指针域 rchild，如下图所示： 其中，n 个结点的二叉链表中含有 n+1 [ 2n-(n-1)=n+1 ] 个空指针域。 二、线索二叉树 传统的二叉链表仅能体现出一种父子关系，不能直接得到结点在遍历中的前驱或后继。引入线索二叉树正是为了加快查找结点前驱和后继的速
【数据结构】线索二叉树
最新发布
ProcyonX的博客
10-23 773
Ltag = 0时，LChild域指向结点的左孩子。Ltag=1时， LChild域指向结点的遍历前驱。Rtag=0时，RChild域指向结点的右孩子。Rtag=1时，RChild域指向结点的遍历后继。
《数据结构》—— 线索二叉树的基础认识、存储结构、图，线索化代码实现。
博樽
10-02 2544
线索二叉树的基本概念线索、构造、存储结构； 中、先、后序遍历结构图；画出线索二叉树，以及二叉树线索化的代码实现。
线索二叉树【定义、应用、线索化、遍历】
GlowYi
04-19 3415
1、定义 对于具有n个节点的二叉树，采用二叉链存储结构时，每个节点有两个指针域，总共有2n个指针域，又由于只有n-1个节点被有效指针所指向，则共有2n-(n-1)=n+1个空链域。 空的左孩子指针指向该结点的前驱；空的右孩子指针指向该结点的后继。这种附加的指针值称为线索，带线索的二叉树称为线索二叉树。  在不同的遍历次序下，二叉树中的每个结点一般有不同的前...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值