线索二叉树操作详解（详细图例+cpp实现+源码）

最新推荐文章于 2024-09-10 09:40:32 发布
最新推荐文章于 2024-09-10 09:40:32 发布
阅读量2.2k 收藏 21
点赞数 6
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jj6666djdbbd/article/details/128135328
版权

文章目录

线索二叉树

线索二叉树又称为二叉树的线索化。

在一个具有n个节点的二叉树中，它含有n+1个空指针链域，如果我们把这些空指针链域利用起来，用它来记录当前节点的前驱节点与后继节点，这些指针被称为线索。 加上线索的二叉树成为线索二叉树。

线索二叉树：

  • 先序线索二叉树
  • 中序线索二叉树
  • 后序线索二叉树

我们在本节主要讨论中序线索二叉树。

线索二叉树的优势：

  1. 利用线索二叉树进行中序遍历时，不必采用堆栈处理，速度较一般二叉树的遍历速度快，且节约存储空间。
  2. 任意一个结点都能直接找到它的前驱和后继结点。

中序线索二叉树

解析： 中序线索二叉树

这颗二叉树的中序遍历结果： 1 1 2 4 5 9 注意：我们使用了一个头节点（值为0）作为特殊的线索，在二叉树中本身并不包含这个头节点。

黑色指针链： 代表节点之间的正常的左右孩子关系。
红色指针链： 代表线索，即指针此节点的前驱与后继节点

注意：我们所讨论的前驱与后继都是根据这个二叉树的中序遍历的序列的位置关系。

  1. 根节点的左子树 1： 它是一个叶子节点，所以具有线索，左线索指向前驱节点，但是注意由于其前驱为空，所以规定他指向头节点；右线索指向其后继，在中序遍历中指向根节点1。
  2. 节点2：它的左为子树为空，所以它应该具有左线索，指向其前驱，应该为根节点1.
  3. 节点4：同第一步的节点1一致，具有左线索与右线索，分别指向前驱与后继节点，即节点2和节点5.
  4. 节点9：它是中序遍历的末尾节点，也是叶子节点，左线索指向前驱，即它的中序遍历前一个节点5；右线索指向后继，它没有后继，因此指向头节点。
  5. 注意：头节点也应该具有线索，左线索指向根节点，右线索指向这颗树的中序遍历的最后一个节点，即最右节点。

在这里插入图片描述

构造线索二叉树

我们经过上面的图分析后，可以得知：线索二叉树其实就是普通的二叉树，然后又加了指向其前驱与后继的线索。
那么如何表示左右指针链与线索呢？

存储结构：

template <typename T>
struct TreeNode
{
	T data;		//节点的值
	TreeNode* pleft, * pright;	//左右指针
	int ltag, rtag;		//表示有没有左右线索
};

  • ltag：是否具有左线索

    • 值为0： 直接用作普通的指针链即可，pelft指向其左孩子节点
    • 值为1： 它具有线索：此时pleft指向其当前节点的前驱节点。

  • rtag：是否具有右线索

    • 值为0： 直接用作普通的指针链即可，pright指向其右孩子节点
    • 值为1： 它具有线索：此时pright指向其当前节点的后继节点。

节点的线索化

当我们明确了二叉树节点的存储结构之后，我们便可以按照我们的思路来完成线索化了。

主要思路：
中序遍历一颗树，在中序遍历的过程中，检查当前节点的左右指针是否为空，为空则指向当前节点的前驱节点与后继节点。

请注意：既然需要前驱节点与后继节点，那么我们显然需要一个 pre节点，即指向当前节点的前驱节点的指针，用它来连接。

过程：

  1. 首先创建一个头节点pHead，用它来确保中序遍历的序列的首元节点和尾节点能够被线索化。
  2. 首先遍历左子树。
  3. 如果当前遍历的节点 p->pleft 不为空，则 p->ltag 置为0； p->pright 不为空，则 p->rtag 置为0，表示左右指针不需要线索化。
  4. 如果当前遍历的节点 p->pleft 为空，则 p->ltag 置为1，p->pleft指向其前驱节点 pre ； p->pright 为空，则 pre ->rtag 置为1，pre->pright指向其后继节点 p，表示左右指针需要线索化。（注意这个右线索化时，我们当前节点是p，前驱节点是pre，我们既然要让 p 连接后继节点，不如反过来让pre连接p。）
  5. 然后遍历右子树，递归，执行相同的操作。

代码示例：

template<typename T>
TreeNode<T>* Tree<T>::_createThread_Tree(TreeNode<T>* bt)
{
	//增加一个头节点
	TreeNode<T>* pHead = new TreeNode<T>{ 0,nullptr,bt,0,1 };
	//1. 判断这颗树是否是空的。
	if (bt == nullptr)
	{
		pHead->ltag = 0;
		pHead->pleft = pHead;
		pHead->rtag = 1;
		pHead->pright = nullptr;
	}
	else
	{
		//2. bt不为空树，则开始线索化。
		pHead->pleft = bt;	//（1）首先头节点的左指针线索化树根节点
		pre = pHead;		//（2）前驱节点首先设置为头节点
		_Thread(bt);		//（3）开始树中各个节点的线索连接
		//结束后，pre指向根节点  进行头节点根节点的连接
		pHead->pright = pre;	
		pre->rtag = 1;				
		pre->pright = pHead;
	}
	//返回头节点
	return pHead;
}
template<typename T>
void Tree<T>::_Thread(TreeNode<T>*& bt)
{	
	if (bt != nullptr)
	{
		//递归进入右子树，开始线索化
		_Thread(bt->pleft);	
		//直到其左指针为空，则需要将左指针线索化。
		//左指针指向其前驱节点，ltag标记为1
		if (bt->pleft == nullptr)
		{
			bt->pleft = pre;
			bt->ltag = 1;
		}
		else
		{
			//左指针不为空，则不需要线索化，ltag设置为0
			bt->ltag = 0;
		}
		//如果节点右指针为空，则需要将右指针线索化。
		//右指针指向其后继节点，rtag标记为1
		//注意： 当前节点与后继节点的连接可以转换为 ---> 前驱节点与当前节点(当作后继节点)的连接
		if (pre->pright == nullptr)
		{
			pre->pright = bt;
			pre->rtag = 1;
		}
		else
		{
			pre->rtag = 0;
		}
		//每次完成一个节点的操作后，前驱节点记得要更新为当前节点，然后当前节点接着往下遍历
		pre = bt;
		_Thread(bt->pright);	//递归进入右子树，开始线索化
	}
}

如果你对 _Thread线索化函数感到难以理解，我们来一步步图解这个过程：

  1. 首先p一路递归到其左指针等于空的时候，开始线索化：左指针指向其前驱节点，此时pre默认为头节点（我们自定义的），左指针指向头节点，ltag标记为1；pre的右指针为空，pre的右指针指向当前节点，rtag标记为1，接着递归进入节点4的右子树。
    在这里插入图片描述

  2. 节点4右指针为空，因此递归返回一层，返回到节点3。pre指向其前驱节点4。可以发现节点3的左指针不为空，因此ltag标记为0，无需对左指针进行线索化。pre的右指针为空，进行pre右指针的线索化，连接其后继节点。pre的pright连接当前节点p，标记ltag为1，此时就完成了节点4的线索化。
    在这里插入图片描述

  3. 接着递归进入节点3的右子树中，到达节点5，它的左指针为空，因此进行左线索化，连接其前驱节点pre，标记节点5的ltag为1。此时 节点3的线索化就完成了！ 然后递归进入节点5的右子树。
    在这里插入图片描述

  4. 节点5的右指针为空，因此返回递归，到达了节点2，pre指向节点5。节点2的左指针不为空，因此ltag标记0。pre的右指针为空，pre的右指针指向p，rtag标记为1，接着递归进入节点2的右子树，为空，则返回上一层。对于节点5的线索化也完成了！
    在这里插入图片描述

  5. p到达节点1，pre到达节点2，p的左指针不为空，无需线索化，ltag标记为0。pre的右指针为空，需要线索化，pre的右指针指向p，rtag标记为1，节点2的线索化就完成了！

在这里插入图片描述
6. 接下来进入节点1的右子树的递归，为空，所以返回上一层，递归结束，返回到函数中。头节点的右指针连接到pre上，rtag标记为1，根节点的右指针也连接到头节点上，rtag标记为1，此时整棵树的线索化就完成了！

在这里插入图片描述

如何来检测结果的正确性？
中序遍历序列：

4 ---- 3 ----- 5 ----- 2 ------ 1
4的前驱为头节点，后继为节点3。（线索化）
3的前驱为节点4，后继是节点5。（无需线索化）
5的前驱是节点3，后继是节点2。（线索化）
2的前驱是节点5，后继是节点1。（右线索化）
1的前驱是节点2，后继是根节点。（右线索化）
根节点始终与中序遍历的最后一个节点的右指针互相连接。

其他操作

销毁二叉搜索树

如果 ltag和rtag都等于0，表示节点具有左右子树；如果都不等于1，则相当于上面的叶子节点4一样，递归到了树底层，则删除此节点。

template<typename T>
void Tree<T>::_destroyTH(TreeNode<T>*& bt)
{
	//左子树不为空，递归到最后一个左子树叶子节点
	if (bt->ltag == 0)
	{
		_destroyTH(bt->pleft);
	}
	//右子树不为空，递归到最后一个右子树叶子节点
	if (bt->rtag == 0)
	{
		_destroyTH(bt->pright);
	}
	delete bt;
	bt = nullptr;
}

获取中序遍历的第一个节点

当最后一个节点的ltag为1时，则表示到达了最后。

template<typename T>
TreeNode<T>* Tree<T>::FindMidFirst()
{
	TreeNode<T>* begnode = root->pleft;
	while (begnode->ltag == 0)
	{
		begnode = begnode->pleft;
	}
	return begnode;
}

获取中序遍历的最后一个节点

头节点与中序遍历的最后一个节点相互连接，因此它的右指针就是中序遍历的最后一个节点。

template<typename T>
TreeNode<T>* Tree<T>::FindMidLast()
{
	return root->pright;
}

输出中序遍历序列

template<typename T>
TreeNode<T>* Tree<T>::PreNode(TreeNode<T>* p)
{
	auto find = p->pleft;
	if (p->ltag != 1)
	{
		while (find->rtag == 0)
		{
			find = find->pright;
		}
	}
	return find;
}

template<typename T>
void Tree<T>::_midtavel()
{
	TreeNode<T>* node;
	node = FindMidFirst();
	while (node != root)
	{
		cout << node->data << " ";
		node = NextNode(node);
	}
	cout << endl;
}

逆序输出中序遍历序列

template<typename T>
TreeNode<T>* Tree<T>::NextNode(TreeNode<T>* p)
{
	auto find = p->pright;
	if (p->rtag != 1)
	{
		while (find->ltag == 0)
		{
			find = find->pleft;
		}
	}
	return find;
}

template<typename T>
void Tree<T>::_rmidtravel()
{
	auto node = FindMidLast();
	while (node != root)
	{
		cout << node->data << " ";
		node = PreNode(node);
	}
	cout << endl;
}

源码

#include <iostream>
#include <algorithm>
#include <vld.h>
#include <vector>
#include <stack>
#include <list>
using namespace std;

template <typename T>
struct TreeNode
{
	T data;
	TreeNode* pleft, * pright;
	int ltag, rtag;
	TreeNode(const T& data = 0) 
		:data(data), pleft(nullptr), pright(nullptr),rtag(0),ltag(0) {}
	TreeNode(const T& data, TreeNode* pleft, TreeNode* pright, int ltag, int rtag)
		:data(data), pleft(pleft), pright(pright), ltag(ltag), rtag(rtag) {}
};

template <typename T = int>
class Tree
{
public:
	Tree();
	~Tree();
	void CreateTree(const T& val);
	//中序遍历序列
	void MidTravel();
	//逆中序遍历序列
	void rMidTravel();
	void CreateThreadTree();
	void destroyThreadTree();
	void destroyTree();

	//查找中序遍历的第一个节点
	TreeNode<T>* FindMidFirst();
	//得到中序遍历的最后一个节点
	TreeNode<T>* FindMidLast();
private:
	//找P节点的中序前驱节点
	TreeNode<T>* PreNode(TreeNode<T>* p);
	//找P节点的中序后继节点
	TreeNode<T>* NextNode(TreeNode<T>* p);
	void _destroyTree(TreeNode<T>*& bt);
	void _midtavel();
	void _rmidtravel();
	void _createTree(TreeNode<T>*& root,const T& val);
	TreeNode<T>* _createThread_Tree(TreeNode<T>* bt);
	void _Thread(TreeNode<T>*& bt);
	void _destroyTH(TreeNode<T>*& bt);
private:
	TreeNode<T>* root;
	TreeNode<T>* pre;
};

int main()
{
	Tree<> a;
	int arr[]{ 1,2,5,4,1,9 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		a.CreateTree(arr[i]);
	}
	a.CreateThreadTree();
	auto beg =  a.FindMidFirst();
	auto end = a.FindMidLast();
	a.MidTravel();
	a.rMidTravel();
	return 0;
}

template<typename T>
Tree<T>::Tree()
{
	root = nullptr;
	pre = nullptr;
}

template<typename T>
Tree<T>::~Tree()
{
	if (pre == nullptr)
	{
		destroyTree();
	}
	else
	{
		destroyThreadTree();
	}
}

template<typename T>
void Tree<T>::CreateTree(const T&val)
{
	_createTree(root, val);
}

template<typename T>
void Tree<T>::MidTravel() 
{
	_midtavel();
}

template<typename T>
void Tree<T>::rMidTravel()
{
	_rmidtravel();
}

template<typename T>
void Tree<T>::CreateThreadTree()
{
	root = _createThread_Tree(root);
}

template<typename T>
void Tree<T>::destroyThreadTree()
{
	auto pNode = root->pleft;		//保存下一个节点的位置
	delete root;	//删除头节点的内存
	root = nullptr;
	_destroyTH(pNode);
	pre = nullptr;
}

template<typename T>
void Tree<T>::destroyTree()
{
	_destroyTree(root);
	root = nullptr;
}

template<typename T>
TreeNode<T>* Tree<T>::FindMidFirst()
{
	TreeNode<T>* begnode = root->pleft;
	while (begnode->ltag == 0)
	{
		begnode = begnode->pleft;
	}
	return begnode;
}

template<typename T>
TreeNode<T>* Tree<T>::FindMidLast()
{
	return root->pright;
}

template<typename T>
TreeNode<T>* Tree<T>::PreNode(TreeNode<T>* p)
{
	auto find = p->pleft;
	if (p->ltag != 1)
	{
		while (find->rtag == 0)
		{
			find = find->pright;
		}
	}
	return find;
}

template<typename T>
TreeNode<T>* Tree<T>::NextNode(TreeNode<T>* p)
{
	auto find = p->pright;
	if (p->rtag != 1)
	{
		while (find->ltag == 0)
		{
			find = find->pleft;
		}
	}
	return find;
}

template<typename T>
void Tree<T>::_destroyTree(TreeNode<T>*& bt)
{
	if (bt != nullptr)
	{
		_destroyTree(bt->pleft);
		_destroyTree(bt->pright);
		delete bt;
	}
}

template<typename T>
void Tree<T>::_midtavel()
{
	TreeNode<T>* node;
	node = FindMidFirst();
	while (node != root)
	{
		cout << node->data << " ";
		node = NextNode(node);
	}
	cout << endl;
}

template<typename T>
void Tree<T>::_rmidtravel()
{
	auto node = FindMidLast();
	while (node != root)
	{
		cout << node->data << " ";
		node = PreNode(node);
	}
	cout << endl;
}

template<typename T>
void Tree<T>::_createTree(TreeNode<T>*& root, const T& val)
{
	if (root == nullptr)
	{
		root = new TreeNode<T>{ val };
		return;
	}
	if (val <= root->data)
	{
		_createTree(root->pleft, val);
	}
	else
	{
		_createTree(root->pright, val);
	}
}

template<typename T>
TreeNode<T>* Tree<T>::_createThread_Tree(TreeNode<T>* bt)
{
	//增加一个头节点
	TreeNode<T>* pHead = new TreeNode<T>{ 0,nullptr,bt,0,1 };
	if (bt == nullptr)
	{
		pHead->ltag = 0;
		pHead->pleft = pHead;
		pHead->rtag = 1;
		pHead->pright = nullptr;
	}
	else
	{
		//bt不为空树
		pHead->pleft = bt;
		pre = pHead;			//前驱节点默认为头节点
		_Thread(bt);	//线索连接
		//结束后，pre指向根节点  进行头节点根节点的连接
		pHead->pright = pre;	
		pre->pright = pHead;
		pre->rtag = 1;				
	}
	//返回头节点
	return pHead;
}

template<typename T>
void Tree<T>::_Thread(TreeNode<T>*& bt)
{	
	if (bt != nullptr)
	{
		_Thread(bt->pleft);	//递归进入右子树，开始线索化
		//线索化
		if (bt->pleft == nullptr)
		{
			bt->pleft = pre;
			bt->ltag = 1;
		}
		else
		{
			bt->ltag = 0;
		}
		if (pre->pright == nullptr)
		{
			pre->pright = bt;
			pre->rtag = 1;
		}
		else
		{
			pre->rtag = 0;
		}
		//node.emplace_back(bt);
		pre = bt;
		_Thread(bt->pright);	//递归进入右子树，开始线索化
	}
}

template<typename T>
void Tree<T>::_destroyTH(TreeNode<T>*& bt)
{
	//左子树不为空，递归到最后一个左子树叶子节点
	if (bt->ltag == 0)
	{
		_destroyTH(bt->pleft);
	}
	//右子树不为空，递归到最后一个右子树叶子节点
	if (bt->rtag == 0)
	{
		_destroyTH(bt->pright);
	}
	delete bt;
	bt = nullptr;
}
Yuleo_
关注
专栏目录
二叉树的线索化
罗小黑の窝
02-25 643
头文件：函数的声明 #include #include #include #define MAXSIZE 100 typedef char ElemType; typedef enum { Link,/*指向孩子结点*/Thread/*指向前驱或后继*/ } PointerTag; typedef struct Node { ElemType data; struct Node *l
线索二叉树详解（C语言版）.rar
04-10
博文测试用例，博文链接：https://blog.csdn.net/qq_44075108/article/details/115583744
线索二叉树
仰望星空
11-06 1820
/* 线索二叉树 运行环境：vs2010 */ #include #include #include #include #define NIL '#' #define OK 1 #define ERROR 0 typedef struct thread_bitree_node thrbitree; typedef enum { LINK, //指针 THREAD //线
【高阶数据结构】线索二叉树的构建和相关操作（精美图解+完整代码）
最新发布
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
09-10 785
构建线索二叉树，对二叉树进行线索化，线索二叉树的一系列相关操作。
【数据结构】线索二叉树（适用场景+图文推导过程+C语言代码实现）
crr411422的博客
03-31 5230
在实际问题中，如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。我们对二叉树以某种次序遍历使其变为线索二叉树的过程称做是线索化。
数据结构（C语言）-- 线索二叉树
weixin_44977283的博客
07-30 556
有 2n 个指针，2n - (n - 1) = n + 1 个指针没有用。* 利用这个n + 1个指针，来指向我们二叉树遍历序列当中的前驱和后继。先序线索二叉树：是指如果节点没有左右孩子，则指针指向先序遍历的前驱和后继。* 线性结构有前驱有后继。我们使用线索将二叉树转换成类似的线性结构。* 如果一个二叉树有 n 个节点，那么有多少个指针指向这些节点？线索其实就是将节点连在一起的指针；* 有 n-1 个指针指向他们。* 一共有多少个指针？* 左 --> 前驱。* 右 --> 后继。
PHP实现的线索二叉树及二叉树遍历方法详解
01-20
本文实例讲述了PHP实现的线索二叉树及二叉树遍历方法。分享给大家供大家参考，具体如下： <?php require 'biTree.php'; $str = 'ko#be8#tr####acy#####'; $tree = new BiTree($str); $tree->...
二叉树前中后序遍历+重建+输出.cpp
06-09
基于C++的数据结构：二叉树前中后序遍历+重建+输出 以前课程作业写的代码
基于C和C++实现二叉树编码的遗传算法实现数据拟合源码+实验报告+答辩PPT(课设作业).zip
05-06
基于C和C++实现二叉树编码的遗传算法实现数据拟合源码+实验报告+答辩PPT(课设作业).zip基于C和C++实现二叉树编码的遗传算法实现数据拟合源码+实验报告+答辩PPT(课设作业).zip基于C和C++实现二叉树编码的遗传算法实现...
【数据结构】- 详解线索二叉树（C 语言实现）
melonyzzZ的博客
11-29 705
一、线索二叉树的基本概念 二、构造线索二叉树 三、遍历线索二叉树
线索二叉树详解（C语言版）
qq_44075108的博客
04-10 4211
线索二叉树详解（C语言版）
线索二叉树详解 - C语言
友人帐_的博客
10-26 6218
介绍了线索二叉树的概念及数据结构，分析了优缺点。并给出中序遍历线索化的示例，指出线索二叉树的一些应用。
线索二叉树(C语言详解----画图理解)
qq_50372003的博客
11-23 1270
树的进阶篇2
数据结构37：线索二叉树的创建
weixin_30786617的博客
05-16 185
通过前面对二叉树的学习，了解到二叉树本身是一种非线性结构，采用任何一种遍历二叉树的方法，都可以得到树中所有结点的一个线性序列。在这个序列中，除第一个结点外，每个结点都有自己的直接前趋；除最后一个结点外，每个结点都有一个直接后继。 图1 满二叉树 例如，图 1 采用先序遍历的方法得到的结点序列为：1 2 4 5 3 6 7，在这个序列中，结点 2 的直接前趋结点为 1，直接后继结点为 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yuleo_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值