数据结构线索二叉树(C++)

最新推荐文章于 2024-05-31 14:42:05 发布
最新推荐文章于 2024-05-31 14:42:05 发布
阅读量202 收藏 2
点赞数 1
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57796792/article/details/121580211
版权

数据结构线索二叉树(C++)

概念

由于二叉树定义的时候，结点有的没有儿子指针，设置为NULL，为了不浪费这部分空间，于是利用原有的空指针域来存放结点的前驱和后继指针。一般约定，利用空的leftChild域存放结点的前驱结点指针，利用空的rightChild域存放结点的后继结点指针。这一类指示前驱和后继的指针叫做“线索”，加上了线索的二叉树叫做线索二叉树。

线索

在每个结点中设置两个标志ITag和RTag。如果ITag=0，表示leftChild域存放的是左儿子指针，否则为前驱结点，如果RTag=0，表示rightChild域存放的是右儿子指针，否则为后继结点。

线索二叉树函数的功能

线索二叉树结构体结点定义

template<class T>
struct ThreadNode
{
	T data;
	ThreadNode<T> *leftChild;
	ThreadNode<T> *rightChild;
	int LTag;
	int RTag;
	ThreadNode() :leftChild(NULL), rightChild(NULL), LTag(0), RTag(0) {}
	ThreadNode(T item) :data(item), leftChild(NULL), rightChild(NULL), LTag(0), RTag(0) {}
};

线索二叉树类体的定义

template <class T>
class ThreadTree
{
public:
	ThreadTree();
	~ThreadTree();
	void preOrderCreate(char endTag='#');
	void preOrderCreate(ThreadNode<T> *&root,char endTag='#');//前序遍历创建线索二叉树
	void createInThread();
	void createInThread(ThreadNode<T> *current, ThreadNode<T> *&pre);//中序建立线索二叉树
	void InOrder();
	void InOrder(ThreadNode<T>* p);
	void PreOrder();
	void PreOrder(ThreadNode<T>* p);
	void PostOrder();
	void PostOrder(ThreadNode<T>* p);
	ThreadNode<T>* Parent(ThreadNode<T>* p);

	ThreadNode<T>* First(ThreadNode<T>* current);//返回以current为根中序遍历下的第一个结点
	ThreadNode<T>* Last(ThreadNode<T>* current);//返回以current为根中序遍历下的最后一个结点
	ThreadNode<T>* Prior(ThreadNode<T>* current);//返回cuurent中序遍历下的前驱结点
	ThreadNode<T>* Next(ThreadNode<T>* current);//返回cuurent中序遍历下的后继结点
private:
	ThreadNode<T> *root;
	void destroy(ThreadNode<T> *p);
};

构造函数

template<class T>
ThreadTree<T>::ThreadTree()
{
	root = NULL;
}

析构函数

~ThreadTree()
{
	destroy(root);
}
template<class T>
void ThreadTree<T>::destroy()
{
	if (root == NULL)
			return;
	destroy(root->leftChild);
	destroy(root->rightChild);
	delete root;
}

前序遍历建立二叉树

template<class T>
void ThreadTree<T>::preOrderCreate(char endTag)
{
	preOrderCreate(root);
}
template<class T>
void ThreadTree<T>::preOrderCreate(ThreadNode<T> *&root,char endTag)
{
	T element;
	cin >> element;
	if (element == endTag)
		return;
	root = new ThreadNode<T>(element);
	assert(root != NULL);
	preOrderCreate(root->leftChild, endTag);
	preOrderCreate(root->rightChild, endTag);
}

中序遍历完成线索二叉树

template<class T>
void ThreadTree<T>::createInThread()
{
	ThreadNode<T> *pre = NULL;
	if (root != NULL)
	{
		createInThread(root, pre);
		pre->rightChild = NULL;//最后一个结点没有后继
		pre->RTag = 1;//当createInThread(含参)的函数执行完毕后，pre指向最后一个结点
	}
}
template<class T>
void ThreadTree<T>::createInThread(ThreadNode<T> *current, ThreadNode<T> *&pre)
{
	if (current == NULL)
		return;//当前结点为空则返回
	createInThread(current->leftChild, pre);//左子树线索化
	if (current->leftChild == NULL)
	{
		current->leftChild = pre;
		current->LTag = 1;
	}
	if (pre != NULL && pre->rightChild == NULL)//在前驱结点中添加后继线索
	{
		pre->rightChild=current;//pre!=NULL加入判断条件
		pre->RTag = 1;
	}
	pre = current;//当前结点完成后，current->rightChild的前趋结点就为current,即pre
	createInThread(current->rightChild, pre);//右子树线索化
}

注意

  1. 参数pre使用的是*&
  2. 在遍历过程中pre始终指向结点的前驱结点。即中序遍历过程中刚刚访问过的结点。
  3. 在做中序遍历的时候一遇到空指针域就进行填入。

线索二叉树的前序遍历

template<class T>
void ThreadTree<T>::PreOrder()
{
	if (root != NULL)
		PreOrder(root);
}
template<class T>
void ThreadTree<T>::PreOrder(ThreadNode<T>* p)
{
	while (p != NULL)
	{
		cout << p->data << " ";
		if (p->LTag == 0)
			p = p->leftChild;
		else if (p->RTag == 0)
			p = p->rightChild;
		else
		{
			while (p != NULL && p->RTag == 1)//沿后继线索检测
				p = p->rightChild;//直到有右子女的结点
			if (p != NULL)
				p = p->rightChild;//右子女即为后继
		}
	}
	//ABC##DE#G##F###
	//A B C D E G F 前序遍历
	//C B E G D F A 中序遍历
}

若当前结点有左儿子，则前序下的后继结点为左儿子结点，否则，如果有右儿子，则后继节点为右儿子。对于叶子结点，则沿中序后继线索走到一个有右儿子结点的结点，这个右儿子结点即当前结点的前序后继结点（由于中序遍历和前序遍历的共同点是先访问了左儿子结点，右儿子结点未访问，因此去找一个有右儿子的后继结点去继续访问）。

线索二叉树的中序遍历

template<class T>
void ThreadTree<T>::InOrder()
{
   if(root!=NULL)
   	InOrder(root);
}
template<class T>
void ThreadTree<T>::InOrder(ThreadNode<T>* p)
{
   for (p = First(p); p!=NULL; p = Next(p))
   	cout << p->data << " ";
}

中序遍历线索二叉树会非常方便，找到中序遍历下的第一个结点，一直寻找后继结点然后输出即可。

线索二叉树的后序遍历

template<class T>
void ThreadTree<T>::PostOrder()
{
	if (root != NULL)
		PostOrder(root);
}
template<class T>
void ThreadTree<T>::PostOrder(ThreadNode<T>* p)
{
	while (p->LTag == 0 || p->RTag == 0)
		if (p->LTag == 0)
			p = p->leftChild;
		else if (p->RTag == 0)
			p = p->rightChild;//找到后序遍历的第一个结点
	cout << p->data << " ";
	ThreadNode<T> *father;
	while ((father = Parent(p)) != NULL)
	{
		if (father->rightChild == p || father->RTag == 1)
			p = father;
		else
		{
			p = father->rightChild;
			while (p->LTag == 0 || p->RTag == 0)
				if (p->LTag == 0)
					p = p->leftChild;
				else if (p->RTag == 0)
					p = p->rightChild;
		}
		cout << p->data << " ";
	}
}

寻找某个结点的父结点

ThreadNode<T>* ThreadTree<T>::Parent(ThreadNode<T>* p)
{
	if (p == root)
		return NULL;
	ThreadNode<T>* t;
	for (t = p; p->LTag == 0; p = p->leftChild);
	if (p->leftChild != NULL)
		for (p = p->leftChild; p != NULL && p->leftChild != t && p->rightChild != t; p = p->rightChild);
	if (p == NULL || p->leftChild == NULL) 
	{
		for (p = t; p->RTag == 0; p = p->rightChild);
		for (p = p->rightChild; p != NULL && p->leftChild != t && p->rightChild != t; p = p->rightChild);
	}
	return p;
}

返回某个结点为根的中序遍历下的第一个结点

template<class T>
ThreadNode<T>* ThreadTree<T>::First(ThreadNode<T>* current)
{
	ThreadNode<T> *p=current;
	while (p->LTag == 0)
		p = p->leftChild;//最左下角结点，不一定是叶子结点
	return p;
}

返回某个结点为根的中序遍历下的最后一个结点

template<class T>
ThreadNode<T>* ThreadTree<T>::Last(ThreadNode<T>* current)
{
	ThreadNode<T>* p=current;
	while (p->RTag == 0)
		p = p->rightChild;//最右下角结点，不一定是叶子结点
	return p;
}

返回结点在中序遍历下的前驱结点

template<class T>
ThreadNode<T>* ThreadTree<T>::Prior(ThreadNode<T>* current)
{
	ThreadNode<T>* p = current->leftChild;
	if (current->LTag == 0)
		return Last(p);
	else
		return p;
}

返回结点在中序遍历下的后继结点

template<class T>
ThreadNode<T>* ThreadTree<T>::Next(ThreadNode<T>* current)
{
	ThreadNode<T>* p = current->rightChild;
	if (current->RTag == 0)
		return First(p);
	else
		return p;
}

完整代码

#include<iostream>
#include<assert.h>
using namespace std;
template<class T>
struct ThreadNode
{
	T data;
	ThreadNode<T> *leftChild;
	ThreadNode<T> *rightChild;
	int LTag;
	int RTag;
	ThreadNode() :leftChild(NULL), rightChild(NULL), LTag(0), RTag(0) {}
	ThreadNode(T item) :data(item), leftChild(NULL), rightChild(NULL), LTag(0), RTag(0) {}
};
template <class T>
class ThreadTree
{
public:
	ThreadTree();
	~ThreadTree() { destroy(root); }
	void preOrderCreate(char endTag='#');
	void preOrderCreate(ThreadNode<T> *&root,char endTag='#');//前序遍历创建线索二叉树
	void createInThread();
	void createInThread(ThreadNode<T> *current, ThreadNode<T> *&pre);//中序建立线索二叉树
	void InOrder();
	void InOrder(ThreadNode<T>* p);
	void PreOrder();
	void PreOrder(ThreadNode<T>* p);
	void PostOrder();
	void PostOrder(ThreadNode<T>* p);
	ThreadNode<T>* Parent(ThreadNode<T>* p);

	ThreadNode<T>* First(ThreadNode<T>* current);//返回以current为根中序遍历下的第一个结点
	ThreadNode<T>* Last(ThreadNode<T>* current);//返回以current为根中序遍历下的最后一个结点
	ThreadNode<T>* Prior(ThreadNode<T>* current);//返回cuurent中序遍历下的前驱结点
	ThreadNode<T>* Next(ThreadNode<T>* current);//返回cuurent中序遍历下的后继结点
private:
	ThreadNode<T> *root;
	void destroy(ThreadNode<T>* p)
	{
		if (root == NULL)
			return;
		destroy(root->leftChild);
		destroy(root->rightChild);
		delete root;
	}
};
template<class T>
ThreadTree<T>::ThreadTree()
{
	root = NULL;
}
template<class T>
void ThreadTree<T>::preOrderCreate(char endTag)
{
	preOrderCreate(root);
}
template<class T>
void ThreadTree<T>::preOrderCreate(ThreadNode<T> *&root,char endTag)
{
	T element;
	cin >> element;
	if (element == endTag)
		return;
	root = new ThreadNode<T>(element);
	assert(root != NULL);
	preOrderCreate(root->leftChild, endTag);
	preOrderCreate(root->rightChild, endTag);
}
template<class T>
void ThreadTree<T>::createInThread()
{
	ThreadNode<T> *pre = NULL;
	if (root != NULL)
	{
		createInThread(root, pre);
		pre->rightChild = NULL;//最后一个结点没有后继
		pre->RTag = 1;//当createInThread(含参)的函数执行完毕后，pre指向最后一个结点
	}
}
template<class T>
void ThreadTree<T>::createInThread(ThreadNode<T> *current, ThreadNode<T> *&pre)
{
	if (current == NULL)
		return;//当前结点为空则返回
	createInThread(current->leftChild, pre);//左子树线索化
	if (current->leftChild == NULL)
	{
		current->leftChild = pre;
		current->LTag = 1;
	}
	if (pre != NULL && pre->rightChild == NULL)//在前驱结点中添加后继线索
	{
		pre->rightChild=current;
		pre->RTag = 1;
	}
	pre = current;//当前结点完成后，current->rightChild的前趋结点就为current,即pre
	createInThread(current->rightChild, pre);//右子树线索化
}
template<class T>
void ThreadTree<T>::InOrder()
{
	if(root!=NULL)
		InOrder(root);
}
template<class T>
void ThreadTree<T>::InOrder(ThreadNode<T>* p)
{
	for (p = First(p); p!=NULL; p = Next(p))
		cout << p->data << " ";
}
template<class T>
void ThreadTree<T>::PreOrder()
{
	if (root != NULL)
		PreOrder(root);
}
template<class T>
void ThreadTree<T>::PreOrder(ThreadNode<T>* p)
{
	while (p != NULL)
	{
		cout << p->data << " ";
		if (p->LTag == 0)
			p = p->leftChild;
		else if (p->RTag == 0)
			p = p->rightChild;
		else
		{
			while (p != NULL && p->RTag == 1)//沿后继线索检测
				p = p->rightChild;//直到有右子女的结点
			if (p != NULL)
				p = p->rightChild;//右子女即为后继
		}
	}
	//ABC##DE#G##F###
	//A B C D E G F 前序遍历
	//C B E G D F A 中序遍历
}
template<class T>
void ThreadTree<T>::PostOrder()
{
	if (root != NULL)
		PostOrder(root);
}
template<class T>
void ThreadTree<T>::PostOrder(ThreadNode<T>* p)
{
	while (p->LTag == 0 || p->RTag == 0)
		if (p->LTag == 0)
			p = p->leftChild;
		else if (p->RTag == 0)
			p = p->rightChild;//找到后序遍历的第一个结点
	cout << p->data << " ";
	ThreadNode<T> *father;
	while ((father = Parent(p)) != NULL)
	{
		if (father->rightChild == p || father->RTag == 1)
			p = father;
		else
		{
			p = father->rightChild;
			while (p->LTag == 0 || p->RTag == 0)
				if (p->LTag == 0)
					p = p->leftChild;
				else if (p->RTag == 0)
					p = p->rightChild;
		}
		cout << p->data << " ";
	}
}
template<class T>
ThreadNode<T>* ThreadTree<T>::Parent(ThreadNode<T>* p)
{
	if (p == root)
		return NULL;
	ThreadNode<T>* t;
	for (t = p; p->LTag == 0; p = p->leftChild);
	if (p->leftChild != NULL)
		for (p = p->leftChild; p != NULL && p->leftChild != t && p->rightChild != t; p = p->rightChild);
	if (p == NULL || p->leftChild == NULL) 
	{
		for (p = t; p->RTag == 0; p = p->rightChild);
		for (p = p->rightChild; p != NULL && p->leftChild != t && p->rightChild != t; p = p->rightChild);
	}
	return p;
}
template<class T>
ThreadNode<T>* ThreadTree<T>::First(ThreadNode<T>* current)
{
	ThreadNode<T> *p=current;
	while (p->LTag == 0)
		p = p->leftChild;//最左下角结点，不一定是叶子结点
	return p;
}
template<class T>
ThreadNode<T>* ThreadTree<T>::Last(ThreadNode<T>* current)
{
	ThreadNode<T>* p=current;
	while (p->RTag == 0)
		p = p->rightChild;//最右下角结点，不一定是叶子结点
	return p;
}
template<class T>
ThreadNode<T>* ThreadTree<T>::Prior(ThreadNode<T>* current)
{
	ThreadNode<T>* p = current->leftChild;
	if (current->LTag == 0)
		return Last(p);
	else
		return p;
}
template<class T>
ThreadNode<T>* ThreadTree<T>::Next(ThreadNode<T>* current)
{
	ThreadNode<T>* p = current->rightChild;
	if (current->RTag == 0)
		return First(p);
	else
		return p;
}
int main()
{
	ThreadTree<char> Tree;
	Tree.preOrderCreate();
	Tree.createInThread();
	Tree.InOrder();
	cout << endl;
	Tree.PreOrder();
	cout << endl;
	Tree.PostOrder();
	cout << endl;
}
豆瓣鸡
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++实现的线索二叉树
weixin_44148719的博客
08-24 328
线索二叉树的概念就不赘述了，最核心的定义就是：结构体中左右标志位的选取，本文中以ltag表示左节点，当ltag为false时，放置左孩子，true时放置前驱节点指针，同理，以rtag表示左节点，当rtag为false时，放置右孩子，true时放置后继节点指针。 以下代码中有详细注释~????（不过线索二叉树真的好难懂鸭） typedef struct BiTreeNode { char data; BiTreeNode *lchild; BiTreeNode *rchild; bool ltag
C++ 线索二叉树
nightwizard2030的博客
04-14 871
所谓线索二叉树其实就是利用n+1个空指针所浪费的空间，n+1个指针能形成n条链，来保存节点的前驱后继，而形成一个链状的排列。对于线索二叉树的原理，应该是基于中序遍历而衍生出来的，把3个节点看做一个整体，那么最左边能留出前驱，最右边能留出后继，而这3个节点已经用2个指针连成了一条线，以此类推，足以保证树中所有节点都被连在一条线上。 代码用上一篇二叉树的代码就行修改，node 增添 leftTag、
线索化二叉树C++
J.Anson的博客
11-19 1597
线索化二叉树 1.创建二叉树 2.先序递归遍历输出二叉树 3.线索化二叉树 4.输出线索化二叉树
数据结构 线索二叉树 c++
weixin_30673715的博客
05-18 91
以二叉链表来作为储存结构的时候，只能找到左右孩子的信息，不能直接得到结点的前驱和后继信息，这种信息只有在遍历的过程中才能实现。在n个结点的二叉链表中必定存在n+1个空链域。可以用这些空链域来保存这些信息；做以下规定：若结点有左子树，则lchild指向其左孩子，若没有左孩子则指向其前驱；若结点有右子树，则rchild指向其右子树，否则指向其后继；为了标志指针是线索还是指针，需要添加两个标志位来表示指...
c/c++数据结构线索二叉树(408)
qq_46264842的博客
08-14 500
线索二叉树
数据结构之线索二叉树
y_k_j_c的博客
10-19 543
二叉树的性质导致有n+1个空指针域这些空指针域，就可以用来存储，对应节点在对应的前驱和后继来储存这些节点这样的话从数的如何一个节点出发，来推它的中序遍历就看起来更可行了。
数据结构-线索二叉树
echoagod的博客
08-07 426
线索二叉树
考研数据结构之线索二叉树
qq_56012214的博客
04-30 813
线索二叉树
数据结构-二叉树的线索化（C++）
Toby的博客
11-19 810
本文为数据结构-二叉树的线索化（C++）的笔记，欢迎参考！
C/C++数据结构实现二叉树的遍历与线索二叉树
12-26
使用C/C++实现二叉树的构造、先序遍历、中序遍历、后序遍历、中序线索化、线索化后的中序遍历等基本树操作。
C语言数据结构之线索二叉树及其遍历
08-29
主要介绍了C语言数据结构之线索二叉树及其遍历的相关资料,为了加快查找节点的前驱和后继。对二叉树的线索化就是对二叉树进行一次遍历，在遍历的过程中检测节点的左右指针是否为空，如果是空，则将他们改为指向前驱和...
C++数据结构-二叉树和线索二叉树
01-03
基于二叉链表的二叉树，实现了二叉树的多种操作：添加、删除、拷贝、清空、树深度计算、父节点...使用模板偏特化继承并实现了线索二叉树，实现了中序线索建立、遍历算法和迭代器。程序编码风格良好，关键算法注释详细。
数据结构（C++）上课笔记——线索二叉树的概念与C++实现(2020-5-12).doc
05-21
数据结构（C++）上课笔记——线索二叉树的概念与C++实现(2020-5-12)，详细记录上课内容，并附有可调试成功的代码，很好的复习、编程参考资料
数据结构 C++ STL 二叉树
01-21
二叉树 二叉树的递归遍历和非递归遍历 二叉树的迭代器 线索二叉树（中序）
C++中的智能指针类别
最新发布
GOLOJO的博客
05-31 669
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 805
string类各函数接口。
【如何在Qt C++中使用SSL和TLS加密传输数据？】
m0_45463480的博客
05-28 170
在这个示例中，我们创建了一个简单的Qt应用程序，向指定的HTTPS地址发送请求，并显示响应。信号来处理响应数据。您可以从响应中读取数据并进行进一步处理。来配置SSL/TLS连接，包括对证书进行验证和加密要求等。为您要访问的实际URL，并根据需要进一步配置SSL策略。在发送请求之前，可设置SSL配置。确保您的Qt项目已经链接了网络模块（对象发送网络请求，并接收响应。对象指定要访问的URL。
C语言——指针
weixin_45725380的博客
05-31 498
存储类型 数据类型 *指针变量名；例如：int *p;//定义了一个整数型指针变量pint a=5;int *p=&a;char b='v';char *q=&b;访问指针所指的空间里的内容时，需要用取内容运算符*来获取此时，变量p存放的就是a的地址，变量q存放的就是b的地址；符号*可以访问地址指向的空间里面的内容。指针与变量之间的关系如下：int i=3;本质还是指针，指向的是数组。（又称为行指针）所谓指针数组就是由若干个具有相同类型的指针变量组成的集合。
C语言数据结构线索二叉树
10-20
线索二叉树是一种特殊的二叉树，它的每个节点都有两个指针，一个指向其左子树，一个指向其右子树。除此之外，每个节点还有两个指针，一个指向其前驱节点，一个指向其后继节点。这些指针被称为线索。线索化就是将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值