线索化二叉树&&线索化后的二叉树遍历

最新推荐文章于 2024-12-17 21:19:02 发布
最新推荐文章于 2024-12-17 21:19:02 发布
阅读量695 收藏 2
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/IT_iverson/article/details/78758332
版权

能看到线索化二叉树这块的对于一些概念性的问题肯定就有了一定的了解，这里就不多说了，下面直接上正餐

因为线索话的话，当左子树为为空的时候我们需要让其指向其前驱元素，当右子数为空的时候我们需要让其指向其后继的元素，这样就把整个二叉树线索化起来了，因为我们就需要标记一下左右子树是否被线索花，在这里我们用枚举来作为标记

enum//用来标记是否线索化，LINK表示有左右子树没有被线索化，THREAD表示被线索化
{
	LINK,
	THREAD,
};

因为我是用C++写的，所以这里先给出创建二叉树的代码

#include<iostream>
using namespace std;
#pragma once
enum//用来标记是否线索化，LINK表示有左右子树没有被线索化，THREAD表示被线索化
{
	LINK,
	THREAD,
};
template<class T>
struct BinTreeNode
{
	BinTreeNode<T> *lchild;
	BinTreeNode<T> *rchild;
	int leftflag;//左边的标志
	int rightflag;//右边的标志
	T _data;
	BinTreeNode(T& data)
		:_data(data)
		, lchild(NULL)
		, rchild(NULL)
		, leftflag(LINK)
		, rightflag(LINK)
	{}
};
template<class T>
class BinNode
{
public:
	typedef BinTreeNode<T> * _PNode;
	typedef BinTreeNode<T> Node;
private:
	_PNode _pRoot;
public:
	BinNode()
		:_pRoot(NULL)
	{}
	BinNode(T *array, size_t size, T invalue)//创建一颗二叉树
		:_pRoot(NULL)
	{
		size_t index = 0;
		_CreatNode(_pRoot, array, size, index, invalue);
	}
private:
	void _CreatNode(_PNode &pRoot, T* array, size_t size, size_t& index, T invalue)//创建一颗二叉树
		{
			if (index >= size||invalue == array[index])
				return;
			pRoot= new Node(array[index]);
			_CreatNode(pRoot->lchild, array, size, ++index, invalue);
			_CreatNode(pRoot->rchild, array, size, ++index, invalue);
		}
};
int  main()
{
	char *arr = "ABD##E##CF###";
	BinNode<char> s(arr, strlen(arr), '#');
	system("pause");
	return 0;
}


然后在在上面的基础上添加线索花的功能！

一.前序遍历的顺序线索化二叉树&&前序顺序遍历线索化后的二叉树

首先给出我二叉树的形象图


①前序遍历的顺序线索化二叉树代码如下（递归）

大致思路就是：首先线索花当前结点的左子树和右子树（即根节点），然后标记当前结点，然后判断是否被线索花（即是否有左右子树）然后递归遍历其左子树和右子数，结合代码和图理解

void _PreThreadTree(_PNode pRoot,_PNode &pre)//前序线索化二叉树
	{
		if (NULL == pRoot)
		{
			return;
		}
		if (pRoot->lchild == NULL)//左子树和右子树都确定不需要的时候再进行
		{
			pRoot->lchild = pre;
			pRoot->leftflag = THREAD;
		}
		if (pre != NULL&&pre->rchild == NULL)//没有右子树
		{
			pre->rchild = pRoot;
			pre->rightflag = THREAD;//线索标记
		}
		pre = pRoot;//pre记录当前的结点
		if (pRoot->leftflag == LINK)//如果没有线索花进去，避免不必要的开销
		 _PreThreadTree(pRoot->lchild,pre);
		if (pRoot->rightflag==LINK)
			_PreThreadTree(pRoot->rchild,pre);
	}
②前序顺序遍历线索花后的二叉树代码如下：

这个很简单就根据线索化后的一直往下找就可以了！

void _PreOrder(_PNode pRoot)//前序遍历线索花二叉树
	{
		while(pRoot->leftflag==LINK)
		{
			cout << pRoot->_data << " ";
			pRoot = pRoot->lchild;
		}
		cout << pRoot->_data << " ";
		while (pRoot->rightflag==THREAD)
		{
			pRoot = pRoot->rchild;
			cout << pRoot->_data << " ";
		}
	}
测试结果：

二.中序遍历的顺序线索花二叉树&&中序顺序遍历线索化后的二叉树
首先给出代码的二叉树的形象图

①中序遍历的顺序线索化二叉树代码如下

这个思路和前序的很类似就是只不是先递归到左子树，然后线索化左子树，然后递归到右子树

void _InThreadTree(_PNode pRoot, _PNode &pre)//中序线索化二叉树
	{
		if (pRoot == NULL)
		{
			return;
		}
		if (pRoot->leftflag==LINK)
		_InThreadTree(pRoot->lchild,pre);//一直遍历处理左子树
		if (pRoot->lchild == NULL)//如果左子树为空，线索化左子树
		{
			pRoot->lchild = pre;
			pRoot->leftflag = THREAD;
		}
		if (pre != NULL&&pre->rchild == NULL)
		{
			pre->rchild = pRoot;
			pre->rightflag = THREAD;
		}
		pre = pRoot;
		if (pRoot->rightflag==LINK)
		_InThreadTree(pRoot->rchild,pre);
	}
②中序遍历中序线索化后的二叉树 

void _InOrder(_PNode pRoot)//线索化中序遍历
	{
		while (pRoot)
		{
			while (pRoot->leftflag == LINK)//先遍历左子树，如果被线索化证明左子树遍历完了
			{
				pRoot = pRoot->lchild;
			}
			cout << pRoot->_data << " ";//打印当前根节点
			while ((pRoot->leftflag == THREAD))//开始遍历右子树
			{
				pRoot = pRoot->rchild;
				cout << pRoot->_data << " ";
			}
			pRoot = pRoot->rchild;//左子树彻底处理完了处理右子树
		}
	}
测试结果：

三.后序遍历的顺序线索化二叉树

首先给出二叉树的形象图


后序遍历线索花的代码如下：

void _PostThreadTree(_PNode pRoot, _PNode &pre)//后续序线索化二叉树
	{
		if (pRoot)
		{
			_PostThreadTree(pRoot->lchild, pre);
			_PostThreadTree(pRoot->rchild, pre);
			if (pRoot->lchild == NULL)
			{
				pRoot->lchild = pre;
				pRoot->leftflag = THREAD;
			}
			if (pre&&pre->rchild == NULL)
			{
				pre->rchild = pRoot;
				pre->rightflag = THREAD;
			}
			pre = pRoot;
		}
	}
思路和前中的思路也很相似这里就不多说了，自己对照代码理解。

对于后序线索化的后序遍历因为比较复杂这里先不说了！可以自己去了解。

下面给出全部的代码

#include<iostream>
using namespace std;
#pragma once
enum//用来标记是否线索化，LINK表示有左右子树没有被线索化，THREAD表示被线索化
{
	LINK,
	THREAD,
};
template<class T>
struct BinTreeNode
{
	BinTreeNode<T> *lchild;
	BinTreeNode<T> *rchild;
	int leftflag;//左边的标志
	int rightflag;//右边的标志
	T _data;
	BinTreeNode(T& data)
		:_data(data)
		, lchild(NULL)
		, rchild(NULL)
		, leftflag(LINK)
		, rightflag(LINK)
	{}
};
template<class T>
class BinNode
{
public:
	typedef BinTreeNode<T> * _PNode;
	typedef BinTreeNode<T> Node;
private:
	_PNode _pRoot;
public:
	BinNode()
		:_pRoot(NULL)
	{}
	BinNode(T *array, size_t size,T invalue)//创建一颗二叉树
		:_pRoot(NULL)
	{
		size_t index = 0;
		_CreatNode(_pRoot, array, size, index, invalue);
	}
	void PreThreadTree()//前序线索花二叉树
	{
		_PNode pre = NULL;//记录前一个结点的位置
		_PreThreadTree(_pRoot,pre);
	}
	void InThreadTree()//中序线索花二叉树
	{
		_PNode pre = NULL;//记录前一个结点的位置
		_InThreadTree(_pRoot, pre);
	}
	void PostThreadTree()//后序线索化二叉树
	{
		_PNode pre = NULL;
		_PostThreadTree(_pRoot, pre);
	}
	void PreOrder()//前序遍历
	{
		_PreOrder(_pRoot);
	}
	void InOrder()//中序遍历
	{
		_InOrder(_pRoot);
	}
private:
	void _CreatNode(_PNode &pRoot, T* array, size_t size, size_t& index, T invalue)//创建一颗二叉树
	{
		if (index >= size||invalue == array[index])
			return;
		pRoot= new Node(array[index]);
		_CreatNode(pRoot->lchild, array, size, ++index, invalue);
		_CreatNode(pRoot->rchild, array, size, ++index, invalue);
	}
	//前序遍历的顺序：A  B  D  E C F
	void _PreThreadTree(_PNode pRoot,_PNode &pre)//前序线索化二叉树
	{
		if (NULL == pRoot)
		{
			return;
		}
		if (pRoot->lchild == NULL)//左子树和右子树都确定不需要的时候再进行
		{
			pRoot->lchild = pre;
			pRoot->leftflag = THREAD;
		}
		if (pre != NULL&&pre->rchild == NULL)//没有右子树
		{
			pre->rchild = pRoot;
			pre->rightflag = THREAD;//线索标记
		}
		pre = pRoot;//pre记录当前的结点
		if (pRoot->leftflag == LINK)//如果没有线索花进去，避免不必要的开销
		 _PreThreadTree(pRoot->lchild,pre);
		if (pRoot->rightflag==LINK)
			_PreThreadTree(pRoot->rchild,pre);
	}
	//中序遍历的顺序:C B E A F C
	void _InThreadTree(_PNode pRoot, _PNode &pre)//中序线索化二叉树
	{
		if (pRoot == NULL)
		{
			return;
		}
		if (pRoot->leftflag==LINK)
		_InThreadTree(pRoot->lchild,pre);//一直遍历处理左子树
		if (pRoot->lchild == NULL)//如果左子树为空，线索化左子树
		{
			pRoot->lchild = pre;
			pRoot->leftflag = THREAD;
		}
		if (pre != NULL&&pre->rchild == NULL)
		{
			pre->rchild = pRoot;
			pre->rightflag = THREAD;
		}
		pre = pRoot;
		if (pRoot->rightflag==LINK)
		_InThreadTree(pRoot->rchild,pre);
	}
	//后续遍历的顺序：D E B F C A
	void _PostThreadTree(_PNode pRoot, _PNode &pre)//后续序线索化二叉树
	{
		if (pRoot)
		{
			_PostThreadTree(pRoot->lchild, pre);
			_PostThreadTree(pRoot->rchild, pre);
			if (pRoot->lchild == NULL)
			{
				pRoot->lchild = pre;
				pRoot->leftflag = THREAD;
			}
			if (pre&&pre->rchild == NULL)
			{
				pre->rchild = pRoot;
				pre->rightflag = THREAD;
			}
			pre = pRoot;
		}
	}
	void _PreOrder(_PNode pRoot)//前序遍历线索花二叉树
	{
		while(pRoot->leftflag==LINK)
		{
			cout << pRoot->_data << " ";
			pRoot = pRoot->lchild;
		}
		cout << pRoot->_data << " ";
		while (pRoot->rightflag==THREAD)
		{
			pRoot = pRoot->rchild;
			cout << pRoot->_data << " ";
		}
	}
	void _InOrder(_PNode pRoot)//线索化中序遍历
	{
		while (pRoot)
		{
			while (pRoot->leftflag == LINK)//先遍历左子树，如果被线索化证明左子树遍历完了
			{
				pRoot = pRoot->lchild;
			}
			cout << pRoot->_data << " ";//打印当前根节点
			while ((pRoot->leftflag == THREAD))//开始遍历右子树
			{
				pRoot = pRoot->rchild;
				cout << pRoot->_data << " ";
			}
			pRoot = pRoot->rchild;//左子树彻底处理完了处理右子树
		}
	}
};
int  main()
{
	char *arr= "ABD##E##CF###";
	BinNode<char> s(arr, strlen(arr), '#');
	/*s.PreThreadTree();*/
	/*s.InThreadTree();*/
	s.PostThreadTree();
	/*s.PreOrder();*/
	/*s.InOrder();*/
	system("pause");
	return 0;
}

线索化二叉树及其遍历
Android小白
09-17 393
1.概念 n个结点的二叉链表中含有n+1个空指针域。 利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索") 例如为10的这个节点，它的前驱节点为3，后继节点为1. 2.中序线索化代码 public class Main { public static void main(String[] args) { HeroNode root = new HeroNode(1, "tom" ); HeroNode node
线索化二叉树以及遍历线索化二叉树
我不想学习但是必须学习
11-02 145
问题的提出 线索化二叉树的介绍
二叉树的线索化以及线索二叉树的遍历
Ning_zhi_t的博客
08-19 335
头文件 #include"stdio.h" #include"assert.h" #include"malloc.h" typedef char DataType; typedef enum{ LINK, THREAD }PointFlag; typedef struct BinTreeNode { struct BinTreeNode* _pLeft; struc...
遍历线索化二叉树(思路分析) [算法与数据结构][Java]
m0_57001006的博客
11-02 489
这个时候很明显是不行的,因为我们线索化之后二叉树的各个节点的指向都有可能会发生变化,这个时候我们需要使用新的方式来遍历线索化之后的二叉树, 那么如果这个时候我们还是使用以前的方式来遍历二叉树会发生什么样的情况?
二叉树及其应用 表达式树 后序线索化和遍历
De-Alf的博客
11-26 876
文章目录实验三 二叉树及其应用0: 背景1：二叉树的创建和遍历需求分析概要设计详细设计调试分析用户使用说明测试结果2：表达式树概要设计详细设计调试分析用户使用说明测试结果 实验三 二叉树及其应用 0: 背景 这是一次数据结构的实验报告。源代码不另附，将文中散乱代码块合在一起即可。 1：二叉树的创建和遍历 需求分析 通过添加虚结点，为二叉树的每一实结点补足其孩子，再对补足虚结点后的二叉树按层次遍历的...
Python实现线索化二叉树 Python实现线索化存储二叉树 Python线索化二叉树的遍历
storyfull
12-28 3163
Python实现线索化二叉树 Python实现线索化存储二叉树 Python线索化二叉树的遍历
中序线索二叉树的遍历（二叉树）
最新发布
m0_49844997的博客
12-17 691
算法特点及适用场景该遍历算法充分利用了中序线索二叉树中存储的线索信息，实现了无需递归和栈辅助的高效中序遍历方式，相比普通二叉树中序遍历（通常需要递归或者借助栈来模拟递归）在一些特定场景下可以节省空间和提高遍历速度。适用于频繁进行中序遍历操作且二叉树结构相对稳定（避免频繁插入、删除导致线索维护复杂）的情况，比如在数据结构可视化展示中需要按照中序顺序呈现二叉树节点信息，或者对表达式树进行求值等应用场景，通过线索二叉树遍历能快速获取节点顺序信息。注意事项及可能遇到的问题在代码实现时，要确保FirstNode和。
前序、中序和后序线索化二叉树及其遍历
zhangjs0201的博客
02-27 1405
线索化：二叉树的左子节点指向的是“前驱节点”，右子节点指向的是“后继节点”。 二叉树的线索化有三种：前序、中序和后序线索化，见下图： 下面是实现前序、中序和后序线索化的代码实现： 前序和中序线索化遍历大致差不多，只不过是顺序不同而已； 后序遍历和前序中序不同，需要给Node节点添加parent属性，借助parent属性进行后序线索化遍历。 代码实现 定义Node节点类 class HeroNode { private int no; private String name;
线索二叉树及其遍历
cmd12138的博客
01-15 3097
1.为什么要对二叉树线索化？ 先看下图二叉树： 不难看出有许多空指针域的存在，那对于有n个结点的二叉树它的空指针域有多少呢？一个n结点二叉树总指针域为2n（每个都有左右孩子两个指针域），而n个结点二叉树含有n-1条分支线，反过来想就是没有多少条分支线就有多少个空指针域，所以空指针域为2n-（n-1）=n+1个，空指针太多浪费内存资源。如果我们能把这些空地址放上结点的前驱和后继，那将会节省很多时间。 2.什么是线索化？ 将二叉树变为线索二叉树的过程称为线索化。 按某种次序将二叉树线索化的实质是：按该次序遍历
线索化二叉树和遍历（中序）
weixin_45713331的博客
08-27 1229
线索化二叉树，按照前序，中序，后序的排列方式，给某些左右节点为空的节点设置了前驱和和后继节点。遍历：因为线索化了二叉树对其中序遍历时，以前的方法会出错。
线索化二叉树及对线索化二叉树的遍历.cpp
04-20
线索化二叉树及对线索化二叉树的遍历.cpp
后序线索化二叉树 +遍历（带头结点）
玩转Java
03-10 1214
后序线索二叉树 #include <stdio.h> #include <malloc.h> #include <string.h> #define maxsize 50 typedef char elemtype; typedef struct node{ elemtype data; struct node *lchild;//指向左孩子 struct node *rchild;//指向右孩子 struct node *parent;//指向双亲结点
二叉树的后序线索化及遍历（Java）
weixin_43967331的博客
09-26 1243
这里把个人的代码记录下来，仅供各位同学参考，代码有不妥之处欢迎指正。 节点类 class HeroNode{ private int no; private String name; private HeroNode left; private HeroNode right; //子节点的类型，0为左子树，1为前驱节点 private int leftType; private int rightType; } 后序线索化 /** 后序线索化
【二叉树】二叉树后序线索化以及后序遍历
菜鸟成长记
02-18 6731
构建节点：多了双亲节点 struct BinaryTreeNodeThd { BinaryTreeNodeThd(const T& data) : _data(data) , _pLeft(NULL) , _pRight(NULL) , _pParent(NULL) , _LeftThread(LINK) , _RightThread(LINK) {} T _data; Bi
03线索二叉树_ThreadBinaryTree
AKK188888881的博客
10-06 457
#include<stdio.h> #include<stdlib.h> #include<math.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间初始分配量 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */ typedef char TElemType; typed
遍历线索化二叉树+图解
Frank---7的博客
03-26 724
图解 代码实现 package com.atguigu.tree.threadedbinarytree; /** * @创建人 wdl * @创建时间 2021/3/25 * @描述 */ public class ThreadedBinaryTreeDemo { public static void main(String[] args) { //测试一把中序线索化二叉树的功能 HeroNode root = new HeroNode(1, "tom")
数据结构——后序线索化二叉树
minyuanxiani的专栏
09-04 1324
#include using namespace std; typedef enum PointerTag {Link,Thread}; //Link==0,Thread==1;线索 typedef struct treenode { struct treenode *left; char data; struct treenod
前，中，后序线索化二叉树并遍历
qq_64431576的博客
09-16 870
前，中，后序线索化二叉树并遍历
画出这棵二叉树的后续线索树并将这棵二叉树转换为对应的树
11-18
由于您提供的信息不足以直接绘制后续线索树，我需要根据之前的描述来推测。根据先序遍历(ABDFCEGH)和中序遍历(BFDAGEHC)，我们知道： - A是根节点 - B在A的左侧，且有D和F作为左子树，G和H作为右子树的后继 - C在A的右侧 为了构建后续线索树（也称后缀线索），我们需要将每个节点的后继标记出来。在后续线索树中，通常会用两个指针表示：一个指向当前节点的直接后继，另一个指向当前节点的间接后继（即后继的后继）。这里假设空节点的后继为null。 基于以上信息，我们可以这样构建后续线索树： ``` A / \ B C / \ D F \ G H (G的后继是H，因为中序是GFH) \ null \ null \ null ``` 注意，由于没有提供具体的后续顺序，这里的`G`和`H`之间的联系是假设的，它们的实际连接可能会根据实际情况而有所不同。如果后续信息明确，这个图会更精确。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值