二叉树线索化以及线索化的先序、中序、后序遍历

最新推荐文章于 2024-05-26 14:39:41 发布
最新推荐文章于 2024-05-26 14:39:41 发布
阅读量5.3w 收藏 244
点赞数 72
分类专栏： 数据结构与算法
本文为博主原创文章，转载需标明出处。
本文链接：https://blog.csdn.net/My_heart_/article/details/52086321
版权

前面已经对二叉树的基本知识和创建，以及二叉树的前序、中序、后序遍历做出了描述和实现。

本篇博客主要讲述：二叉树的线索化以及对线索二叉树遍历实现。


首先，什么是二叉树的线索化，为什么要对二叉树线索化？

二叉树是一种非线性结构，遍历二叉树几乎都是通过递归或者用栈辅助实现非递归的遍历。用二叉树作为存储结构时，取到一个节点，只能获取节点的左孩子和右孩子，不能直接得到节点的任一遍历序列的前驱或者后继。
为了保存这种在遍历中需要的信息，我们利用二叉树中指向左右子树的空指针来存放节点的前驱和后继信息

n个节点的二叉树中含有n+1个空指针域。利用二叉树中的空指针域 来存放在某种遍历次序下的前驱和后继 ，这种指针叫“线索”。这种加上了线索的二叉树称为线索二叉树。

根据线索的性质的不同，线索二叉树分为：前序线索二叉树 ， 中序线索二叉树 ， 后序线索二叉树（本篇博客主要讲述前面两种 ， 后面会专门对后序线索二叉树分析 ）


线索二叉树节点：


typedef enum
{
	Link,  
	Thread
} PointTag;

typedef	struct  BinaryTreeNode
{
	BinaryTreeNode(const char data)
	:_data(data)
	, pLeft(NULL)
	, pRight(NULL)
	, Ltag(Link)
	, Rtag(Link)
	{}
	char _data;
	struct  BinaryTreeNode *pLeft , * pRight;
	PointTag  Ltag, Rtag; 
}BiTreeNode;
 Ltag  标记是否有左子树  ，  Ltag 是Link 则表示有左子树 ； Ltag是Thread表示没有左子树（有前驱）

 Rtag 标记是否有右子树  ，  Rtag是Link 则表示有右子树 ； Rtag是Thread 表示没有右子树（有后继）


首先，在线索化二叉树之前，你得有二叉树吧惊讶

还是 按之前的方式：先序创建二叉树

void  _CreatTree(BiTreeNode*& Root, const char* arr, size_t size, size_t& index)
	{
		if (arr == NULL || size == 0)
		{
			cout << "输入有误 " << endl;
			return;
		}
		if (index < size && arr[index] != '#')
		{
			Root = new BiTreeNode(arr[index]);
			_CreatTree(Root->pLeft, arr, size, ++index);
			_CreatTree(Root->pRight, arr, size, ++index);
		}
	}

以下面的二叉树为例：


1、先序线索化二叉树和遍历
先序遍历的顺序：0 1 2 3 4

先序线索化二叉树

分析：首先对于左子树存在的节点，就不会有前驱；同样，节点的右子树存在，那么不存在后继。那么我就先一直找寻节的左子树，判断左右子树是否为空 ， 为空了才会考虑前驱和后继的问题。后继倒是很好找（反正要遍历二叉树），那么前驱的位置呢？如果遇到左子树不存在的节点，怎么才能找到已经已经扫面过得节点呢？所以我们需要创建一个节点指针，每次记住上一次扫描的节点 。 对于右子树就很好办了 ， 如果当前节点的前一个节点不为空且右子树不存在，那么我们就放心大胆的链上吧 。然后循环得了。


假设 记录前一个节点的指针为：

BiTreeNode* Prev =NULL;

没听懂描述么？ 没关系，如果所示：


上代码：

void _PreOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		if (Root->pLeft == NULL) //没有左子树
		{
			 Root->pLeft = Prev;   //前驱
			Root->Ltag = Thread;
		}
		if (Prev != NULL && Prev->pRight == NULL) // 上一个节点有没有  右子树
		{  //Prev第一次进来 为空  
			Prev->pRight = Root;   //后继
			Prev->Rtag = Thread;
		}
		Prev = Root;//前驱  ， 每次记住上次的节点

		//判断Root是否有左右孩子
		if (Root->Ltag == Link)
			_PreOrderThreading(Root->pLeft);
		if (Root->Rtag == Link)
			_PreOrderThreading(Root->pRight);
	}

对于先序线索二叉树，我想提醒的是： 每次只会把当前节点的左子树前驱链上，这一次的 后继 不会在本次链上，当pCur指向下一个节点的时候，才会把上一次的后继链上

结果：


那么 怎么 写先序遍历线索二叉树呢

void _PreOrder(BiTreeNode* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		BiTreeNode* pCur = Root;
		while (pCur != NULL)
		{
			while (pCur->pLeft != NULL && pCur->Ltag == Link)//找到最左边的节点,左标记一直为Link
			{
				cout << pCur->_data << ' ';
				pCur = pCur->pLeft;
			}
			//到这来，左边的的节点还没有访问
			cout << pCur->_data << ' ';

			if (pCur->Ltag == Thread)//遇到线索 就看右节点
			{
				pCur = pCur->pRight;
			}
			while (pCur != NULL)//循环右节点
			{
				if (pCur->pLeft != NULL && pCur->Ltag == Link)//遇到左节点存在 ， 则访问
				{
					break;
				}
				cout << pCur->_data << ' ';
				pCur = pCur->pRight;
			}
		}
	}
代码解释：



2、中序线索化二叉树和遍历

中序遍历的顺序：213 0 4

中序遍历线索化二叉树

分析：还是和先序很像的 ，中序的顺序是左-根-右，我们同样可以使用上面的递归方式；

话不多说，上代码：

void _InOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		_InOrderThreading(Root->pLeft);    // 左
				
		if (Root->pLeft == NULL)	//根
		{
			Root->Ltag = Thread;
			Root->pLeft = Prev;
		}
		if (Prev != NULL && Prev->pRight == NULL)
		{
			Prev->pRight = Root;
			Prev->Rtag = Thread;
		}
		Prev = Root;
		_InOrderThreading(Root->pRight);   //右
	}
中序遍历线索二叉树 
void _InOrder(BiTreeNode* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		BiTreeNode* pCur = Root;
		while (pCur )
		{
			while (pCur->Ltag == Link) //找最左边的节点
			{
				pCur = pCur->pLeft;
			}
			cout << pCur->_data << ' ';
			while ( pCur && pCur->Rtag == Thread )//找中序后继节点
			{
				pCur = pCur->pRight;
				cout << pCur->_data << ' ';
			}
			//没有后继，有右子树   
			pCur = pCur->pRight;
		}
	}
其实，中序遍历和先序遍历二叉树还是很像的，首先按照中序遍历的顺序，找到二叉树的最左边的节点，判断是否有前驱，有则遍历访问，没有则看右子树和后继的情况。

此处，可以按照之前的画图过程继续一步步来。


全部代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<assert.h>

//线索二叉树 
typedef enum
{
	Link,
	Thread
} PointTag;

typedef	struct  BinaryTreeNode
{
	BinaryTreeNode(const char data)
	:_data(data)
	, pLeft(NULL)
	, pRight(NULL)
	, Ltag(Link)
	, Rtag(Link)
	{}
	char _data;
	struct  BinaryTreeNode *pLeft , * pRight;
	PointTag  Ltag, Rtag;
}BiTreeNode;

class Thread_BiTree
{
public:
	//先序 --创建树
	Thread_BiTree(const char* arr, size_t Size)
		:_pRoot(NULL)
		, Prev(NULL)
	{
		size_t index = 0;
		_CreatTree(_pRoot, arr, Size , index);//创建二叉树
	}
protected:
	void  _CreatTree(BiTreeNode*& Root, const char* arr, size_t size, size_t& index)
	{
		if (arr == NULL || size == 0)
		{
			cout << "输入有误 " << endl;
			return;
		}
		if (index < size && arr[index] != '#')
		{
			Root = new BiTreeNode(arr[index]);
			_CreatTree(Root->pLeft, arr, size, ++index);
			_CreatTree(Root->pRight, arr, size, ++index);
		}
	}
public:
	//先序--线索化二叉树
	void PreOrderThreading()
	{
		_PreOrderThreading(this->_pRoot);
	}
	//先序--遍历 线索二叉树
	void PreOrder()
	{
		_PreOrder(this->_pRoot);
	}
protected:
	//先序--线索化二叉树--C  
	//思路：先看左子树， 找下一个节点的时候，在检测上一个节点的右节点
	void _PreOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		if (Root->pLeft == NULL) //没有左子树
		{
			 Root->pLeft = Prev;   //前驱
			Root->Ltag = Thread;
		}
		if (Prev != NULL && Prev->pRight == NULL) // 上一个节点有没有  右子树
		{  //Prev第一次进来 为空  
			Prev->pRight = Root;   //后继
			Prev->Rtag = Thread;
		}
		Prev = Root;//前驱  ， 每次记住上次的节点

		//判断Root是否有左右孩子
		if (Root->Ltag == Link)
			_PreOrderThreading(Root->pLeft);
		if (Root->Rtag == Link)
			_PreOrderThreading(Root->pRight);
	}
	//先序--遍历 线索二叉树--C
	void _PreOrder(BiTreeNode* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		BiTreeNode* pCur = Root;
		while (pCur != NULL)
		{
			while (pCur->pLeft != NULL && pCur->Ltag == Link)//找到最左边的节点,左标记一直为Link
			{
				cout << pCur->_data << ' ';
				pCur = pCur->pLeft;
			}
			//到这来，左边的的节点还没有访问
			cout << pCur->_data << ' ';

			if (pCur->Ltag == Thread)//遇到线索 就看右节点
			{
				pCur = pCur->pRight;
			}
			while (pCur != NULL)//循环右节点
			{
				if (pCur->pLeft != NULL && pCur->Ltag == Link)//遇到左节点存在 ， 则访问
				{
					break;
				}
				cout << pCur->_data << ' ';
				pCur = pCur->pRight;
			}
		}
	}

public:
	//中序--线索化二叉树
	void InOrderThreading()
	{
		_InOrderThreading(_pRoot);
	}
	//中序--遍历线索二叉树
	void InOrder()
	{
		_InOrder(this->_pRoot);
	}
protected:
	//中序--线索化二叉树--C
	//思路:按 左-根-右的顺序   先找到最左边的节点-> 和先序线索一样 ,先链接左子树，执行到下一个节点在看上次节点的右子树 -> 右子树
	void _InOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		_InOrderThreading(Root->pLeft);    // 左
				
		if (Root->pLeft == NULL)	//根
		{
			Root->Ltag = Thread;
			Root->pLeft = Prev;
		}
		if (Prev != NULL && Prev->pRight == NULL)
		{
			Prev->pRight = Root;
			Prev->Rtag = Thread;
		}
		Prev = Root;
		_InOrderThreading(Root->pRight);   //右
	}
	//中序--遍历二叉树--C
	//思路：找到中序开始的节点（最左边的节点）-> (后继 )它的根节点，若没有则找右节点
	void _InOrder(BiTreeNode* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		BiTreeNode* pCur = Root;
		while (pCur )
		{
			while (pCur->Ltag == Link) //找最左边的节点
			{
				pCur = pCur->pLeft;
			}
			cout << pCur->_data << ' ';

			while ( pCur && pCur->Rtag == Thread )//找中序后继节点
			{
				pCur = pCur->pRight;
				cout << pCur->_data << ' ';
			}
			//没有后继，有右子树   
			pCur = pCur->pRight;
		}
	}
public:
	//后序--线索二叉树
	void PostOrderThreading()
	{
		_PostOrderThreading(_pRoot);
	}
protected:
	//后序--线索二叉数--C
	//思路：左-右-根  和前面的一样
	void _PostOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		_PostOrderThreading(Root->pLeft);
		_PostOrderThreading(Root->pRight);

		if (Root->pLeft == NULL)
		{
			Root->pLeft = Prev;
			Root->Ltag = Thread;
		}
		if (Prev != NULL && Prev->pRight == NULL)
		{
			Prev->pRight = Root;
			Prev->Rtag = Thread;
		}
		Prev = Root;
	}
private:
	BiTreeNode* _pRoot;
	BiTreeNode* Prev;  //记录
};

int main()
{
	//char * arr = "013##4##25##6##";
	char * arr = "012##3##4##";
    Thread_BiTree tree(arr, strlen(arr));

	tree.PreOrderThreading();            //先序线索化
	tree.PreOrder();                   //遍历先序线索二叉树
	cout << endl << "------------------------" << endl;

	char * arr1 = "013##4##25##6##";
	Thread_BiTree tree1(arr1, strlen(arr1));
	tree1.InOrderThreading();          //中序线索化
	tree1.InOrder();                //遍历中序线索二叉树
	cout << endl << "------------------------" << endl;

	char * arr2 = "013##4##25##6##";
	Thread_BiTree tree2(arr2, strlen(arr2));
	tree2.PostOrderThreading();
	tree2.PostOrder();
	cout << endl << "------------------------" << endl;
	return 0;
}

下一篇将详细的讲述，后序线索化二叉树及遍历（我也是花了很大的心思，看了好久才看明白）

PS：祝你们学习愉快，希望能学到知识的同时，分享给渴求知识的各位童鞋



CodingStart
关注
  • 72
    点赞
  • 踩
  • 244
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
线索化二叉树（先序，中序，后序）+线索化二叉树的遍历【java详解】
2302_79862386的博客
02-17 1891
n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种一个结点的前一个结点，称为前驱结点一个结点的后一个结点，称为后继结点//线索化时记录前一个节点//节点存储结构。
【考研】数据结构——线索二叉树
qq_34438969的博客
09-20 4348
本文内容源于对《数据结构（C语言版）》（第2版）、王道讲解学习所得心得、笔记整理和总结。本文针对线索二叉树，在最后的练习中，以举例子说明该排序方法，配以图文，讲解详细（含408真题）。【考研】《数据结构》知识点总结.pdf_考研-其它文档类资源-CSDN下载【2023考研】数据结构常考应用典型例题（含真题）_住在阳光的心里的博客-CSDN博客//二叉树的二又线索存储表示以这种结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表，其中指向结点前驱和后继的指针，叫做线索。
二叉树的前中后序遍历
最新发布
friendhan2005的博客
05-26 214
前中后序的实现
解决先序线索二叉树线索化中出现死循环
强仔的博客
05-24 546
先序线索二叉树遍历出现死循环问题
数据结构之线索二叉树详细解释
热门推荐
m0_61886762的博客
05-02 2万+
1.1 线索二叉树的原理 我们现在倡导节约型社会，一切都应该以节约为本。但当我们创建二叉树时我们会发现其中一共有两个指针域，有的指针域指向的结构为空，这也就浪费了很多空间
线索二叉树，画图教你秒懂线索二叉树（线索二叉树的建立和简单操作）逻辑代码分析
qq_46104786的博客
11-16 1万+
数据结构专升本学习,线索二叉树 前言 前面我们学习树和二叉树的一些基本操作，今天我们学习一个新的知识，学习一下线索二叉树，线索二叉树是由二叉链存储结构变化而来的（我们先得有个二叉链树，再做处理），就是将原来的空域链改为莫种遍历次序下该结点的前驱结点和后继结点的指针，就相当于把我们的空域也利用起来指向下一个要输出的结点，对于下一个结点提高了访问速度，emmm，有点难，博主也有点云里雾里，看博主的解释能不能让你理解。嘿嘿 每日一遍，快乐学习 你们第一次炒菜是不是也是这个样纸！！！！哈哈哈哈 1.什么是线索二叉
线索二叉树(线索链表遍历，二叉树线索化)
m0_63223213的博客
07-27 4992
特别的是，对于D和F，D是中序遍历的开头结点，它没有前驱节点；F是中序遍历的结尾的结点，它没有后继节点，那么这时，寻找的规则是，如果结点的Ltag==1代表可以直接找到前驱节点；由下图可见，有的左右指针是连接的子树，没有链接左右子树的指针现在就通过红色的虚线指向了该结点的前驱或者后继。可以发现，相较于原来的二叉链表，这里在数据结构里添加了两个int类型，来规定左右指针的作用。再通过以下步骤创建一个线索二叉树（下图是中序线索二叉树的结构示意）线索二叉树，即在二叉链表的基础上，将二叉链表的。...
线索二叉树(中序、先序和后序及遍历)
12-21
线索二叉树是一种特殊的二叉树数据...通过中序、先序和后序线索化，我们可以分别实现对二叉树的这三种遍历方式，而无需使用递归或显式的栈。这对于处理大规模的二叉树数据尤其有优势，因为它减少了调用栈的空间开销。
建立二叉树，并输出二叉树的先序，中序和后序遍历序列，以及二叉树的叶子数
12-28
[问题描述] 建立二叉树，并输出二叉树的先序，中序和后序遍历序列，以及二叉树的叶子数。 [基本要求] 要求根据读取的元素建立二叉树，能输出各种遍历。 [实现提示] 可通过输入带空格的前序序列建立二叉链表。
先序线索二叉树、中序线索二叉树和后序线索二叉树
01-01
对先序线索二叉树、中序线索二叉树和后序线索二叉树进行了 C 语言实现，主要包括线索二叉树的建立和遍历过程。
【数据结构】-树-先序线索二叉树，中序线索二叉树，后序线索二叉树
vector的博客
06-14 5372
先序线索二叉树，中序线索二叉树，后序线索二叉树之间的对比 结论： 1.先序线索二叉树找前驱节点困难，找后继节点简单 后序线索二叉树找后继节点困难，找前驱节点简单 中序线索二叉树找前驱节点，后继节点都很简单 2.遍历中序和先序线索二叉树，不需要栈，直接通过线索就可以实现 遍历后序线索二叉树，要用栈 注： 1.三种线索二叉树的叶子节点数都能通过线索直接找到前驱和后继，因此分析能否直接遍历，只需要看前非叶子节点是否能找到自己的前驱和后继就好了。 2.三种遍历前驱和后继的位置 ...
关于线索二叉树的详解
kcy的博客
11-16 1万+
线索二叉树的详解 目录线索二叉树的详解前言一、线索二叉树是什么？三种二叉树线索化实例图二、实现线索二叉树1.二叉树的线索化2.线索二叉树的遍历中序线索二叉树寻找遍历的首节点中序线索二叉树寻找节点的直接后继遍历中序线索二叉树总结 前言 学了二叉树，我们发现，对二叉树的遍历是一个比较复杂的问题，需要用到递归或者栈才可以进行遍历，这样子的遍历实质上就是将二叉树化为一个有序的线性序列，在这个序列中，每一个节点有且只有一个前继节点（第一个节点除外），和一个后继节点（最后一个节点除外），但是这些节点不能直接的找到当
线索化二叉树的作用
学Java，找哪吒
08-16 1万+
一、先看一个问题 将数列{1,3,6,8,10,14}构建成一颗二叉树。 问题分析： 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,6,14}。 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上。 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点，要怎么办？ 解决方案 --> 线索化二叉树 二、线索化二叉树 1、n个节点的二叉树链表总含有n+1（公式2n-(n-1)=n+1）个空指针域。...
数据结构例程——线索化二叉树(中序)
weixin_33755649的博客
10-20 300
本文是数据结构基础系列(6)：树和二叉树中第14课时线索二叉树的例程。 #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct node { ElemTyp...
C++线索二叉树（先序/前序线索二叉树及遍历）
qq_58240448的博客
07-10 2466
使用c++实现 先序/前序线索二叉树及其先序遍历
线索二叉树（C语言实现）——先序线索链表
Mr_John
11-04 1760
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef char DataType; // 标志域利用枚举常量来实现 typedef enum { Link, // Link(0)—指针 Thread // Thread(1)—线索 }flag; typedef struct TNode { DataType data; // 数据域 struct TNode * lc.
线索化二叉树前序、中序、后序遍历
混合编程
12-06 1528
文章目录节点信息前序线索化二叉树前序线索化二叉树遍历中序线索化二叉树中序线索化二叉树遍历后序线索化二叉树后序线索化二叉树遍历 节点信息 public class HeroNode { private int no; private String name; private HeroNode left; private HeroNode right; priv...
前序、中序、后序二叉树的线索化及遍历
优雅永不过时
06-25 1774
先看一个问题 将数列{1，3，6，8，10，14}构建成一颗二叉树 如图 问题分析： 1.当我们对上边的二叉树进行中序遍历时，数列为{8，3，10，1，14，6} 2.但是6，8，10，14这几个节点的左右指针并没有完全利用上 3.如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点怎么办 解决方法-线索二叉树 线索二叉树基本介绍 1.n个节点的二叉链表中含有n+1公式2n-(n-1)=n+1个空指针域。利用二叉链表中的空指针域，存放指向节点在某种遍历次序下的前驱和后继节点的指针（这种
java前序遍历_Java实现线索化二叉树并遍历（前序，中序，后序）
weixin_39822629的博客
02-20 186
/*** 线索化二叉树的节点*/public class IndexNode {public int id;public String name;public IndexNode left;public IndexNode right;public IndexNode parent = null; // 后序线索化的时候需要使用public boolean isLeftIndexed; // 0...
树和二叉树遍历讲解：先序、中序、后序
内容中通过实例展示了不同类型的树和二叉树结构，并对树的遍历进行了详细的阐述，包括先序遍历、后序遍历和层次遍历。" 在计算机科学中，树是一种非线性数据结构，由n个节点组成，每个节点可以有多个子节点。树的...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值