基于c++的线索化二叉树链表

已于 2023-03-18 21:03:13 修改
阅读量1.4k 收藏 1
点赞数 3
分类专栏： c++数据结构 文章标签： 数据结构 c++
于 2022-04-26 21:00:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60948116/article/details/124437071
版权

目录

前序

二叉树中结点类

创建完全二叉树

关于线索化二叉树增加问题：

线索化前的中序遍历

线索化

带头节点的二叉树线索化

 以节点p为根的子树中序线索化

线索化后销毁

总结

源码

前序

对于二叉树的创建有多种方法，但是大部分博客都是使用固定的字符停止增加，比如用“#”等符号或者是干脆使用定长来创建二叉树而且在有些在发布时没有完全使用c++的格式，用了介于c与c++之间的方法来写。但是对于一个小型项目来说，不仅要考虑应该能存多种数据类型，还应该更加符合逻辑，为此我把我大一写的线索化二叉树拿来简单分享一下。

二叉树中结点类

在这里我简单的使用了泛型，不想用的可以直接将T类型数据改成具体数据类型,如：char,string,int...

LTag和RTag主要指线索化之后是否给他前驱后继。0时左右指针正常指向左右孩子，1时左右指针指向前驱后继。

注：在这里我要强调一下关于前驱后继的事，很多时候有些地方并没有把前驱后继讲清楚，在线索化中有中序线索化，后序线索化与前序线索化。由于前驱后继分别指某一个元素遍历后前一个元素与后一个元素，所以线索化不同，前驱后继也分别不同，所以我们一般不用中序线索化后进行后序遍历或者是前序遍历（虽然也能实现，但是要看个人能力了）。

创建完全二叉树

在这为了让增加更加符合逻辑，我选择采取数学的方法进行寻找需要增加的点在哪里。

需要增加的节点只能位于三个位置：

1，增加前那一层已经满，只能增加到下一层的第一个

2，位于树相对与根节点的左侧

3，位于树相对于根节点的右侧

所以对于一个这样的二叉树来说，我们可以这样创建：

1，首先根据数学方法判断下一个要增加的在根节点的哪一边，具体数学方法看下边源码。

2，可以看出需要添加的在根节点的左边，这时用一个临时变量记录根节点的左指针B，这时将B，D，E，H看成一个小树，则它的根节点为临时变量B，这时根据上边的方法接着寻找，直到找到需要增加的位置。

 3，在上述过程中需要增加判断根节点的左右指针是否为空，为空就是要增加的位置，比如：刚开始A的左右指针都不为空，直到最后找到D时，D的右指针为空，就是我们要增加的位置，同时跳出循环，增加成功。

关于线索化二叉树增加问题：

我们知道二叉树在线索化之后，指针指向发生了变化，在线索化前的NULL都被利用指向了它的前驱后继，所以在线索化之后我们一般不进行增加工作。

线索化前的中序遍历

非线索化的中序遍历就是函数的调用，这里就不作过多讲解，可以查看别的博客，一般都很详细。 

线索化

线索化实质是将二叉树中空指针利用起来指向它的前驱后继，而前驱后继的信息刚开始只有在遍历时得到，因此线索化的过程即在遍历中修改空指针的过程。

带头节点的二叉树线索化

 以节点p为根的子树中序线索化

线索化后销毁

很多小伙伴对线索化后如何销毁产生很多疑惑，因为指针指向发生了改变，但是我们依然可以用后序遍历的方法进行销毁，我们都知道线索化后一些原本指向NULL确实发生了改变，但是原先标志域已经由0变成了1，所以我们可以增加一个判断，如果为1就不进入，从而进行后序遍历达到销毁功能。

这里我加了 cout函数，主要是删除一个就显示一下，从而查看是否完全删除，一般小伙伴写后运行时可以不加。

总结

这里我主要介绍一下我的完全二叉树创建的思想，对于一些线索化的过程没有进行过多讲解，有兴趣的小伙伴可以搜搜这方面知识，一般都很详细，我的源码有许多别的功能也没有进行过多的讲解，感兴趣的话可以看看如何实现的。希望如果有别的小伙伴有别的创建二叉数方法可以在下边评论，我们一起学习！！！

源码

//头文件
#include<iostream>
#include<windows.h>
#include<conio.h>
#include<fstream>
#include <cmath>
using namespace std;


//二叉树节点类
template <typename T>
class node
{
private:
	T data;//数据
	node<T>* lchild;//指向左孩子
	int LTag;//0指向左孩子，1指向它的前驱
	node<T>* rchild;//指向右孩子
	int RTag;//0指向右孩子，1指向它的后继
public:
	node()
	{
		lchild = NULL;
		rchild = NULL;
		RTag = 0;
		LTag = 0;
	}
	T& get_data()
	{
		return data;
	}
	void set_lchild(node<T>* lchild = NULL)
	{
		this->lchild = lchild;
	}
	void set_rchild(node<T>* rchild = NULL)
	{
		this->rchild = rchild;
	}
	void set_LTag(int LTag)
	{
		this->LTag = LTag;
	}
	void set_RTag(int RTag)
	{
		this->RTag = RTag;
	}
	node<T>* get_lchild()
	{
		return this->lchild;
	}
	node<T>* get_rchild()
	{
		return this->rchild;
	}
	int get_RTag()
	{
		return this->RTag;
	}
	int get_LTag()
	{
		return this->LTag;
	}
};


//二叉树
template <typename T>
class Tree
{
private:
	node<T>* pre;//上一节点
	node<T>* preroot;//头节点
	node<T>* root;//根
	int number;//存的数量
public:
	Tree()
	{
		preroot = new node<T>;
		preroot->set_lchild(preroot);//初始化pre指针时，让pre的右孩子指向自己
		number = 0;
		root = NULL;
		pre = NULL;
	}
	void Add();//增加
	void AddNode(node<T>* p, node<T>* q, int num);//增加调用函数
	int layer(int num);//求层数，增加用到
	bool ordinary_prin();//普通递归打印中序排列
	void prin(node<T>* p);//普通递归打印所用到的函数中序排列
	bool ordenary_Rev();//普通修改函数
	void Rev(node<T>* p, T e);//普通修改函数调用函数
	void PreTraverse();//初始化pre指针
	void Traver(node<T>* p);//中序遍历线索化二叉树
	void clue_prin();//线索化遍历
	bool clue_Find();//线索化查找
	bool clue_Rev();//线索化修改
	void clue_Dev(node<T>* p);//线索化销毁
	void Dev();//线索化销毁
	void change();//销毁后再次创建需要改变的量
};


//二叉树函数类
//增加思想，无限分割，查看在左还是在右，然后分割成指向NULL；
template <typename T>//求层数
int Tree<T>::layer(int num)
{
	int i = 0;
	while (1)
	{
		i = i + 1;
		if (num <= (pow(2, i) - 1))
		{
			return i;
		}
	}
}
template <typename T>//增加
void Tree<T>::Add()
{
	node<T>* p, * q;
	q = root;
	p = new node<T>;
	cin >> p->get_data();
	p->set_lchild(NULL);
	p->set_rchild(NULL);
	if (root == NULL)//为空创建root
	{
		root = p;
		p->set_lchild(NULL);
		p->set_rchild(NULL);
		number++;
		return;
	}

	AddNode(q, p, number); // 插入左右子树
	return;
}
template <typename T>//增加调用函数
void Tree<T>::AddNode(node<T>* p, node<T>* q, int num)
{
	int c;//存层数
	c = layer(num);
	if ((pow(2, c) - 1) == num)//满
	{
		while (p->get_lchild())
		{
			p = p->get_lchild();
		}
		p->set_lchild(q);
		number++;
		return;
	}
	else if (num - (pow(2, c - 1) - 1) < pow(2, (c - 1)) / 2)//在左
	{
		if (p->get_lchild() == NULL)//左没有
		{
			p->set_lchild(q);
			number++;
			return;
		}
		else if (p->get_rchild() == NULL)//右没有
		{
			p->set_rchild(q);
			number++;
			return;
		}
		else
		{
			num = (int)(num - pow(2, (c - 2)));
			AddNode(p->get_lchild(), q, num);
			//调用
		}
	}
	else//在右
	{
		if (p->get_lchild() == NULL)//左没有
		{
			p->set_lchild(q);
			number++;
			return;
		}
		else if (p->get_rchild() == NULL)//右没有
		{
			p->set_rchild(q);
			number++;
			return;
		}
		else
		{
			num = (int)(num - pow(2, (c - 1)));
			AddNode(p->get_rchild(), q, num);
		}
	}
}
//普通,非线索化
template <typename T>//普通递归打印中序排列
bool Tree<T>::ordinary_prin()
{
	if (root == NULL)
	{
		return false;
	}
	prin(root);
	return true;
}
template <typename T>//普通递归打印所用到的函数中序排列
void Tree<T>::prin(node<T>* p)
{
	if (!p)
	{
		return;
	}
	prin(p->get_lchild());
	cout << p->get_data() << endl;
	prin(p->get_rchild());
}
template <typename T>//普通修改函数
bool Tree<T>::ordenary_Rev()
{
	if (root == NULL)
	{
		cout << "没有数据，无法修改" << endl;
		return false;
	}
	T e;
	cin >> e;
	Rev(root, e);
	return true;
}
template <typename T>//普通修改函数调用函数
void Tree<T>::Rev(node<T>* p, T e)
{
	if (!p)
	{
		return;
	}
	Rev(p->get_lchild(), e);
	if (p->get_data() == e)
	{
		cout << "已经找到" << endl;
		cout << "请输入修改后的数据：" << endl;
		cin >> p->get_data();
		return;
	}
	Rev(p->get_rchild(), e);
}
//线索化
template <typename T>//初始化pre指针
void Tree<T>::PreTraverse()
{
	preroot->set_RTag(1);
	preroot->set_LTag(0);
	preroot->set_rchild(preroot);
	if (!root)//空树
	{
		preroot->set_lchild(preroot);
	}
	else
	{
		preroot->set_lchild(root);// 左孩子为根节点
		pre = preroot; //将二叉树中最左边的节点的左子树指向preroot
		Traver(root);
		// 线索化完毕，此时pre指向二叉树中最右边的节点
		pre->set_RTag(1);
		pre->set_rchild(preroot);
		preroot->set_rchild(pre);//头尾相连,遍历时p!=preroot为结束条件
	}
}
template <typename T>//中序遍历线索化二叉树
void Tree<T>::Traver(node<T>* p)
{
	if (p)//递归结束的条件
	{
		Traver(p->get_lchild());//先移动到最左边开始建线索

		if (!p->get_lchild())//如果此节点没有左孩子
		{
			p->set_LTag(1);
			p->set_lchild(pre);//把pre指针赋给此节点的上一个节点
		}
		if (!pre->get_rchild())
		{
			pre->set_RTag(1);
			pre->set_rchild(p);//上一个节点为p的后继节点
		}
		pre = p;//前移
		Traver(p->get_rchild());//遍历右子数
	}
}
template <typename T>//线索化遍历
void Tree<T>::clue_prin()
{
	node<T>* p = preroot->get_lchild();
	while (p != preroot)
	{
		while (p->get_LTag() == 0)//有左孩子
		{
			p = p->get_lchild();
		}
		cout << p->get_data() << endl;
		while (p->get_RTag() == 1 && p->get_rchild() != preroot)//指向后继
		{
			p = p->get_rchild();
			cout << p->get_data() << endl;
		}
		p = p->get_rchild();//指向后继的下一个，下一个分支
	}
}
template <typename T>//线索化查找
bool Tree<T>::clue_Find()
{
	T data;
	cin >> data;
	if (root == NULL)
	{
		return false;
	}
	node<T>* p;
	p = root;
	while (p != preroot)
	{
		while (p->get_LTag() == 0) // 节点有左孩子，不是后继
		{
			p = p->get_lchild();
		}
		if (p->get_data() == data)
		{
			cout << p->get_data();
			return true;
		}
		while (p->get_RTag() == 1 && p->get_rchild() != preroot) // 节点有后继
		{
			p = p->get_rchild();
			if (p->get_data() == data)
			{
				cout << "已经找到：" << endl;
				cout << p->get_data() << endl;
				return true;
			}
		}
		p = p->get_rchild(); // 往右走，遍历二叉树
	}
	return false;
}
template <typename T>//线索化修改
bool Tree<T>::clue_Rev()
{
	T data;
	cin >> data;
	if (root == NULL)
	{
		return false;
	}
	node<T>* p;
	p = root;
	while (p != preroot)
	{
		while (p->get_LTag() == 0) // 节点有左孩子，不是后继
		{
			p = p->get_lchild();
		}
		if (p->get_data() == data)
		{
			cout << "请输入修改后数据：" << endl;
			cin >> p->get_data();
			return true;
		}
		while (p->get_RTag() == 1 && p->get_rchild() != preroot) // 节点有后继
		{
			p = p->get_rchild();
			if (p->get_data() == data)
			{
				cout << "请输入修改后数据：" << endl;
				cin >> p->get_data();
				return true;
			}
		}
		p = p->get_rchild(); // 往右走，遍历二叉树
	}
	return false;
}
template <typename T>
void Tree<T>::Dev()
{
	if (root == NULL)
	{
		return;
	}
	clue_Dev(root);
}
template <typename T>//线索化销毁
void Tree<T>::clue_Dev(node<T>* p)
{
	if (p == NULL) {
		printf("空节点\n");
		return;
	}
	if (p->get_LTag() != 1)
		clue_Dev(p->get_lchild());
	if (p->get_RTag() != 1)
		clue_Dev(p->get_rchild());
	cout << p->get_data() << endl;
	free(p);
	p = NULL;
	return;
}
template <typename T>//销毁后再次创建所改变的变量
void Tree<T>::change()
{
	preroot->set_lchild(preroot);//初始化pre指针时，让pre的右孩子指向自己
	number = 0;
	root = NULL;
	pre = NULL;
}



//页面函数
void ordinary_menu()
{
	cout << "                            ------------------------------------------------------------" << endl;
	cout << "                           |                       1.增加                               |" << endl;
	cout << "                           |                       2.遍历                               |" << endl;
	cout << "                           |                       3.修改                               |" << endl;
	cout << "                           |                       0.线索化                             |" << endl;
	cout << "                            ------------------------------------------------------------" << endl;
	cout << "                            请选择功能：";
}
void clue_menu()
{
	cout << "                            ------------------------------------------------------------" << endl;
	cout << "                           |                       1.遍历                               |" << endl;
	cout << "                           |                       2.查找                               |" << endl;
	cout << "                           |                       3.修改                               |" << endl;
	cout << "                           |                       0.销毁                               |" << endl;
	cout << "                            ------------------------------------------------------------" << endl;
	cout << "                            请选择功能：";
}


//控制函数
void control()
{
	Tree<int> s;
	int n, f;
	bool b;
	while (1)//外循环销毁之后再次创建
	{
		do
		{
			ordinary_menu();
			cin >> n;
			switch (n)
			{
			case 1://增加
				system("cls");
				cout << "请输入增加数量：";
				cin >> f;//增加几个
				system("cls");
				for (int i = 0; i < f; i++)
				{
					cout << "请输入第" << i + 1 << "个信息" << endl;
					s.Add();
					system("cls");
				}
				break;
			case 2://遍历
				system("cls");
				b = s.ordinary_prin();
				if (b == true)
				{
					cout << "信息显示完毕" << endl;
				}
				else
				{
					cout << "没有存储数据" << endl;
				}
				system("pause");
				system("cls");
				break;
			case 3://修改
				system("cls");
				cout << "请输入要修改的数据：" << endl;
				s.ordenary_Rev();
				system("pause");
				system("cls");
				break;
			case 0://线索化
				s.PreTraverse();
				cout << "已经线索化" << endl;
				system("pause");
				system("cls");
				break;
			default://输入错误
				cout << "选择错误" << endl;
				system("pause");
				system("cls");
			}
		} while (n != 0);
		do
		{
			clue_menu();
			cin >> n;
			switch (n)
			{
			case 1://线索化遍历
				system("cls");
				s.clue_prin();
				system("pause");
				system("cls");
				break;
			case 2://线索化查找
				system("cls");
				cout << "请输入你要查找的数据：" << endl;
				s.clue_Find();
				system("pause");
				system("cls");
				break;
			case 3://线索化修改
				system("cls");
				cout << "请输入你要修改的数据：" << endl;
				b = s.clue_Rev();
				if (b == true)
				{
					cout << "修改成功" << endl;
				}
				else
				{
					cout << "没有存数据或没有该数据" << endl;
				}
				system("pause");
				system("cls");
				break;
			case 0://销毁退出
				s.Dev();
				system("pause");
				break;
			default://输入错误
				cout << "选择错误" << endl;
				system("pause");
				system("cls");
			}
		} while (n != 0);
		system("cls");
		cout << "是否要确定退出,不退出将重新创建：" << endl;
		cout << "1.不退出" << endl;
		cout << "0.退出" << endl;
		cin >> n;
		if (n == 1)//不退出，从新创建
		{
			s.change();
			system("cls");
		}
		else
		{
			break;
		}
	}
	return;
}


//主函数
int main()
{
	control();
	return 0;
}

小z-go
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
C++实现二叉树链表
Vimer.Bai的博客
02-09 2343
C++实现二叉树链表Node.h#ifndef NODE_H #define NODE_H #include <iostream>using namespace std;class Node { public: Node(); ~Node(); Node *SearchNode(int nodeIndex); void DeleteNode(); void P
C++ 二叉树转链表
weixin_44208324的博客
03-16 312
给定一个二叉树，将该二叉树就地(in-place)转换为单链表。单链表中节点顺序为二叉树前序遍历顺序。 如果不要求就地转链表，可以借助于一个vector将二叉树转为链表。代码如下： #include<vector> struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(...
二叉树基本操作以及二叉树线索化操作(C++ 版)
weixin_42295110的博客
07-20 717
线索化的二叉树为: 二叉树线索化的目的: 1.二叉树的线索化的目的是为了快速找到遍历顺序中某个结点的前驱或者后继。 2.二叉树线索化可以实现从某个结点开始遍历二叉树,而不用局限于只能从头结点进行遍历 3.所以二叉树的线索化与遍历序列有关,因为二叉树的遍历序列有三种,所以二叉树的线索化也有三种 a.二叉树的先序线索化 b.二叉树的中序线索化 c. 二叉树的后序线索化 4.二叉树的线索化说白了就是把那n+1个空指针利用起来,指向其前...
线索二叉树的基本概念、构造过程、遍历过程详解及C++代码详细实现
weixin_45651616的博客
07-16 889
数据结构，线索二叉树的基本概念、构造线索二叉树、遍历线索二叉树详解及C++代码详细实现。
创建线索二叉树——中序线索二叉树的遍历（C++实现）
LS_Alice_0820的博客
05-10 1656
中序线索化二叉树
线索二叉树的搭建和遍历（c++版）
weixin_48974458的博客
12-31 149
【代码】线索二叉树的搭建和遍历（c++版）
c++的二叉树
热门推荐
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
C++线索二叉树类实现
07-26
线索二叉树的关键在于线索化，即在二叉链表的左右指针域中增设线索，用于指示其前驱和后继节点。在二叉链表的每个节点中增加两个附加指针，称为线索，分为`ltag`和`rtag`，分别表示左孩子指针是否为前驱线索，右孩子...
中序线索化二叉树及中序遍历
04-01
在实际应用中，为了在非递归情况下高效地进行中序遍历，引入了线索二叉树的概念，特别是中序线索化二叉树。 中序线索化二叉树是在二叉链表的基础上进行修改，使得在任何时刻，通过线索可以确定某个节点是前驱还是...
C++数据结构-二叉树和线索二叉树
01-03
基于二叉链表的二叉树，实现了二叉树的多种操作：添加、删除、拷贝、清空、树深度计算、父节点...使用模板偏特化继承并实现了线索二叉树，实现了中序线索建立、遍历算法和迭代器。程序编码风格良好，关键算法注释详细。
二叉树顺序存储结构的基本操作
11-08
http://blog.csdn.net/ssw_1990/article/details/40511665代码。
二叉树的顺序存储,数据结构
06-03
数据结构课程设计,二叉树 顺序存储 VC++ 数据结构 源代码
线索二叉树_线索二叉树_
10-01
线索二叉树是一种特殊的二叉树数据结构，它在二叉链表的基础上增加了线索，用于在非递归情况下实现前序、中序和后序遍历。这种数据结构主要用于优化二叉树的查找操作，特别是在需要频繁遍历的场景下。 在二叉树中，...
数据结构--二叉树--线索化二叉树
04-19
线索化二叉树是一种特殊的二叉树，它通过在二叉链表的空指针位置附加线索，帮助我们在非递归方式下实现二叉树的遍历。中序遍历是二叉树遍历的一种，按照“左子树-根节点-右子树”的顺序访问节点。 中序线索化二叉树...
二叉树（顺序存储）—— C++实现
浪子花梦
12-21 3523
二叉树 （顺序存储） 物理上内存连在一起，本质是一个数组 逻辑上是一颗树 我们用失量模板类 vector来存储树中的数据，话不多说直接上手，必要的代码注释说明 首先包含我们的头文件及命名空间： #include <iostream> #include <vector> using namespace std; 可以直接定义树的类，不像链式存储需要定义结点那样： tem...
学习C/C++系列（5）二叉树的顺序存储及堆排序
roseisbule的博客
04-13 678
二叉树的顺序存储与堆排序
C++实现二叉树的顺序存储及三种递归遍历
qq_46027243的博客
02-18 576
文章目录 #include<iostream> #include<stack> #include<queue> #include<string.h> using namespace std; #define MaxSize 101 class BinTree { public: BinTree(); void CreatTree(); //生成二叉树 void PreOrderTraverse1(int i=1); //先序递归遍历
C++数据结构——二叉树
eyes++的博客
06-21 1296
一：二叉树的储存结构 1.顺序存储： 用一组地址连续的存储单元，以层序顺序存放二叉树的数据结构元素，结点的相对位置蕴含着节点之间的关系。一般二叉树的顺序存储：把一般的二叉树先补成完全二叉树，然后按照完全二叉树的顺序存储方式进行存储，而新补上去的结点只占位置，不存放结点数据。可见非完全二叉树的顺序存储十分浪费空间 2.链式存储 二叉树链表： 对应的二叉链表结点结构： struct bnode { int data; // 不妨设数据类型为int bnode *lchild, *rchild; };
完全二叉树的顺序储存结构（C++完整代码）
qq_52284035的博客
06-18 8177
完全二叉树的定义：有一颗深度为h、具有n个节点的二叉树，若将它与一颗同深度的满二叉树中的所有节点按从上到下，从左到右的顺序分别进行编号，且该二叉树中的每个节点分别于满二叉树中的编号为1~n ...
用C++写一个线索二叉树的建立，插入，删除，遍历
最新发布
09-18
线索二叉树是一种特殊的二叉树结构，它能够通过线索将原本为空的指针指向前驱或后继节点，从而在遍历过程中提高效率。下面是用C语言实现线索二叉树的建立、插入、删除和遍历的代码示例。 1. 线索二叉树的定义： ``...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值