C++二叉树与线索二叉树

最新推荐文章于 2024-10-01 22:51:02 发布
最新推荐文章于 2024-10-01 22:51:02 发布
阅读量159 收藏
点赞数
文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42848590/article/details/104861716
版权

C++二叉树与线索二叉树

二叉树

1.学过数据结构的朋友应该都知道二叉树吧。 在这里插入图片描述
这是一颗满二叉树，原理自己看书去，了解原理才能够更好的理解代码。我就不在这说原理了。
上代码。

构造一棵二叉树（左子树先构造）

1.这个是模板函数，模板函数的作用是你给定一个类型参数就行了，提高代码复用。就不用为了一个类型重载一个函数啦。

template<typename T>
void Tree<T>::CreateTree(TreeNode<T> *(&Node), list<T> &val)//利用list中栈的原理配置二叉树
{
	if (val.size())
	{
		auto beg = val.begin();
		T c = *beg;
		if (c == ' ')//表示该节点为空，他的父节点没有该叶子节点
		{
			val.pop_front();
			Node = NULL;
		}
		else
		{
			Node = new TreeNode<T>;
			Node->LChild = NULL;
			Node->RChild = NULL;
			Node->Ltag = LINK;//这个是线索树的标记
			Node->Rtag = LINK;//这个是线索树的标记
			Node->data = c;
			val.pop_front();//将顶层数据弹出

			CreateTree(Node->LChild, val);//构造Node的左子树
			CreateTree(Node->RChild, val);//同理构造右子树
		}
	}
}
/*
	list<T>：构造二叉树的原始数据；
	Node：一般是树的根Root;
	通过递归的方式先构造左子树再构造右子树。
*/

在这里插入图片描述
注释：LC=要调用CreateTree(Node->LChild, val);
RC=CreateTree(Node->RChild, val);但凡节点的孩子为空都是用LC,和RC替换。
如果c==’ '，表示该节点为空。

二叉树的非递归遍历

由于递归遍历书上就有，所以不多做解释。
中序遍历的规则：先访问左节点，到根节点，再到右节点，

template<typename T>
void Tree<T>::StackInOrderPrint(TreeNode<T> *Node, stack<TreeNode<T>*> &val)//非递归中序遍历
{
	while (Node || val.size())//存在二叉树时进行遍历
	{
		//当节点存在先入栈，将其左节点地址赋值给Node，直至遍历至最左边的叶子节点
		while (Node)//1,2,3步
		{
			val.push(Node);
			Node = Node->LChild;
		}

		if (val.size())//4，5步
		{
			//当Node为空时，也就是栈顶元素节点的左子树为空时，弹出栈顶元素。
			//Node指向弹出的栈顶元素，打印出数据值，再对其右子树进行遍历。
			Node = val.top();//过去栈顶元素地址
			val.pop();//弹出栈顶元素
			cout << Node->data << " ";
			Node = Node->RChild;
		}
	}
}

/*
	利用压栈以及出栈的方式进行遍历
*/

在这里插入图片描述
到此基本结束了，关闭时要记得delete内存,不要让内存泄露了。

线索二叉树

1.所谓线索二叉树就是提升查找节点前驱和后继的效率，牺牲一点内存，但是充分利用了空指针域。

enum { LINK, CLUES };//LINK表示链接的孩子节点，CLUES链接的是线索节点
template<typename T>
void Tree<T>::CreateCluesHeadNode()//创建一个标记节点，标记作用当前节点的前驱。
{
	if (HeadNode)
	{
		m_PreCluesNode = new TreeNode<T>;
		m_PreCluesNode->Ltag = LINK;//LINK是指向孩子节点
		m_PreCluesNode->Rtag = LINK;
		m_PreCluesNode->RChild = m_PreCluesNode;//指向自己是防止第一次构造线索树的时候出现乱指的问题
		m_PreCluesNode->LChild = HeadNode;
		m_TempCluesNode = m_PreCluesNode;//让中间节点指向线索头节点，在构造线索树中用中间节点，是防止m_PreCluesNode在线索化时地址被篡改，无法被正确析构。
	}
}
/*
	Build一个头指针m_PreCluesNode，使其左孩子指向树的根部。而右孩子指向自己。防止第					一次线索的时候会指向树的左子树的最左叶子节点。
*/	

template<typename T>
TreeNode<T>* Tree<T>::BuildCluesTree(TreeNode<T> *Node)
{
	if(Node)
	{
		BuildCluesTree(Node->LChild);//一直递归到左子树的叶子节点
		
		if (!Node->LChild)//如果Node节点没有左孩子
		{
			Node->Ltag = CLUES;//将标记设置为线索
			Node->LChild = m_TempCluesNode;//左孩子节点指向前一个节点。
		}

		if (!m_TempCluesNode->RChild)//前一个节点的右孩子为空时指向Node节点
		{
			m_TempCluesNode->Rtag = CLUES;
			m_TempCluesNode->RChild = Node;
		}

		m_TempCluesNode = Node;
		BuildCluesTree(Node->RChild);//以右孩子节点作为根节点递归
	}
	return Node;
}

源码：
编译环境：VS2017

//Tree.h
#pragma once
#include<list>
#include<stack>
using namespace std;
enum { LINK, CLUES };//LINK表示链接的孩子节点，CLUES链接的是线索节点

template<typename T>
struct TreeNode
{
	TreeNode<T> *LChild;
	TreeNode<T> *RChild;
	int Ltag;
	int Rtag;
	T data;
};

template<typename T>
class Tree
{
public:
	Tree();
	Tree(list<T> &val);
	~Tree();
	void CreateTree(TreeNode<T> *(&Node), list<T> &val);//创建一个二叉树
	void CreateCluesHeadNode();//创建标记节点记录当前节点的前驱。
	TreeNode<T>* BuildCluesTree(TreeNode<T> *Node);//创建线索树，要先创建标记节点，
	void AddLNode(Tree<T> *Node, T c);//扩充左孩子
	void AddRNode(Tree<T> *Node, T c);//扩充右孩子
	void StackInOrderPrint(TreeNode<T> *, stack<TreeNode<T>*> &val);//非递归中序遍历
	void InOrderPrint(TreeNode<T> *(&));//递归中序遍历
	void Release(TreeNode<T> *(&Node));//释放资源
public:
	TreeNode<T> *HeadNode;//头节点
	TreeNode<T> *m_PreCluesNode;//前驱节点
	TreeNode<T> *m_TempCluesNode;//中间节点，无需析构。
};

template<typename T>
Tree<T>::Tree()
{
}

template<typename T>
Tree<T>::Tree(list<T> &val)
{
	CreateTree(HeadNode, val);
}

template<typename T>
Tree<T>::~Tree()
{
	if (HeadNode)
	{
		Release(HeadNode);
	}

	if (m_PreCluesNode)
	{
		delete m_PreCluesNode;
		m_PreCluesNode = NULL;
	}
}

template<typename T>
void Tree<T>::Release(TreeNode<T> *(&Node))
{
	if (!Node) return;
	TreeNode<T> *LChild=NULL;
	TreeNode<T> *RChild=NULL;
	if (Node->Ltag == LINK)
	{
		LChild = Node->LChild;
	}

	if (Node->Rtag == LINK)
	{
		RChild = Node->RChild;
	}

	if (Node)
	{
		cout << "删除了:" << Node->data << endl;
		delete Node;
		Node = NULL;
	}

	if (LChild)
	{
		Release(LChild);
	}

	if (RChild)
	{
		Release(RChild);
	}
}

template<typename T>
void Tree<T>::CreateTree(TreeNode<T> *(&Node), list<T> &val)//利用list中栈的原理配置二叉树
{
	if (val.size())
	{
		auto beg = val.begin();
		T c = *beg;
		if (c == ' ')
		{
			val.pop_front();
			Node = NULL;
		}
		else
		{
			Node = new TreeNode<T>;
			Node->LChild = NULL;
			Node->RChild = NULL;
			Node->Ltag = LINK;
			Node->Rtag = LINK;
			Node->data = c;
			val.pop_front();

			CreateTree(Node->LChild, val);
			CreateTree(Node->RChild, val);
		}
	}
}
template<typename T>
void Tree<T>::StackInOrderPrint(TreeNode<T> *Node, stack<TreeNode<T>*> &val)//非递归中序遍历
{
	while (Node || val.size())
	{
		while (Node)
		{
			val.push(Node);
			Node = Node->LChild;
		}

		if (val.size())
		{
			Node = val.top();
			val.pop();
			cout << Node->data << " ";
			Node = Node->RChild;
		}
	}
}

template<typename T>
void Tree<T>::AddLNode(Tree<T> *Node, T c)
{

}

template<typename T>
void Tree<T>::AddRNode(Tree<T> *Node, T c)
{

}

template<typename T>
void Tree<T>::InOrderPrint(TreeNode<T> *(&tree))//递归调用
{
	if (tree)
	{
		InOrderPrint(tree->LChild);
		cout << tree->data << " ";
		InOrderPrint(tree->RChild);
	}
}

template<typename T>
TreeNode<T>* Tree<T>::BuildCluesTree(TreeNode<T> *Node)
{
	if(Node)
	{
		BuildCluesTree(Node->LChild);//一直递归到左子树的叶子节点
		
		if (!Node->LChild)//如果Node节点没有左孩子
		{
			Node->Ltag = CLUES;//将标记设置为线索
			Node->LChild = m_TempCluesNode;//左孩子节点指向前一个节点。
		}

		if (!m_TempCluesNode->RChild)//前一个节点的右孩子为空时指向Node节点
		{
			m_TempCluesNode->Rtag = CLUES;
			m_TempCluesNode->RChild = Node;
		}

		m_TempCluesNode = Node;
		BuildCluesTree(Node->RChild);//以右孩子节点作为根节点递归
	}
	return Node;
}

template<typename T>
void Tree<T>::CreateCluesHeadNode()//创建一个标记节点，标记作用当前节点的前驱。
{
	if (HeadNode)
	{
		m_PreCluesNode = new TreeNode<T>;
		m_PreCluesNode->Ltag = LINK;
		m_PreCluesNode->Rtag = LINK;
		m_PreCluesNode->RChild = m_PreCluesNode;//指向自己是防止第一次构造线索树的时候出现乱指的问题
		m_PreCluesNode->LChild = HeadNode;
		m_TempCluesNode = m_PreCluesNode;//让中间节点指向前驱节点，在构造线索树中用中间节点，是防止析构的时候m_PreCluesNode内存改变而无法析构
	}
}

//.cpp
/*
	1.如果你要在函数体中new一个对象的话记得要传引用指针（*(&)或者返回一个指针，
	不然你new的内存就会找不到了，会导致内存泄露。
*/

#include<iostream>
#include"Tree.h"
using namespace std;

int main()
{
	list<char> val{'A','B','D',' ',' ','E',' ',' ','C','F',' ',' ','G',' ',' '};
	Tree<char> *tree;
	stack<TreeNode<char>*> NodeArray;
	tree = new Tree<char>;
	tree->CreateTree(tree->HeadNode,val);
	tree->InOrderPrint(tree->HeadNode);
	cout << endl;
	tree->StackInOrderPrint(tree->HeadNode, NodeArray);
	cout << endl;
	tree->CreateCluesHeadNode();
	tree->BuildCluesTree(tree->HeadNode);
	delete tree;
	system("pause");
	return 0;
}
去吹吹风吧
关注
c++ 实现线索二叉树
天翔龙闪
05-12 451
本代码主要参考了大话数据结构的思想，由于其为c语言版，所以本人对其中一些函数进行了封装，并增加了一些新的功能。改成了更符合现代c++的形式。
C++数据结构-二叉树和线索二叉树
01-03
基于二叉链表的二叉树，实现了二叉树的多种操作：添加、删除、拷贝、清空、树深度计算、父节点...使用模板偏特化继承并实现了线索二叉树，实现了中序线索建立、遍历算法和迭代器。程序编码风格良好，关键算法注释详细。
二叉树、线索二叉树类模版（C++）
11-21
二叉树模版：包括先序中序构造，后序中序构造，结点的度，统计度为n的结点个数，高度，宽度，结点的最大值，交换每个结点的左右，删除叶结点，是否完全二叉树，广度优先遍历，先序遍历，中序遍历，后序遍历； 线索二叉树：包括先序中序构造，中序线索化，中序线索化遍历； 包括测试主函数。
线索二叉树的线索化和析构
Stephan14的专栏
12-15 1038
前段时间学习的二叉树的相关操作，现在又开始学习线索二叉树的相关操作，发现网的一些代码有问题，所以写了这篇博客与大家分享，以下这些代码都是我亲自编写以及调试运行过，有什么错的还请大家指出。 线索二叉树结点的定义如下： template class T> class ThreadNode{//线索二叉树结点声明 private:     int LThread,RThread;    
c++二叉树按照数组进行创建
Yannie's Blog
11-05 663
class TreeMathod{ private: struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} //已经有构造函数了 }; TreeNode* root; public: void CreateTree(vector&
[C++] 二叉树的三种遍历方式
李歇特冯-兹拜因巴哈的博客
06-13 802
二叉树是一种常见的数据结构，这里总结一下二叉树的三种遍历方法的C++实现。从下面的描述中我们可以看到我们使用递归的方式遍历二叉树是非常简洁的，并且代码的形式和几种遍历方式的定义是非常切合的。 二叉树定义 首先需要做的是二叉树的结构定义，我们定义二叉树如下： struct TreeNode { int val; TreeNode* left; TreeNode* right; Tre...
线索二叉树
TechEngineer的专栏
06-06 2964
一、线索二叉树的原理     通过考察各种二叉链表，不管儿叉树的形态如何，空链域的个数总是多过非空链域的个数。准确的说，n各结点的二叉链表共有2n个链域，非空链域为n-1个，但其中的空链域却有n+1个。如下图所示。 因此，提出了一种方法，利用原来的空链域存放指针，指向树中其他结点。这种指针称为线索。     记ptr指向二叉链表中的一个结点，以下是建立线索的规则：
数据结构-二叉树的线索化（C++）
Toby的博客
11-19 873
本文为数据结构-二叉树的线索化（C++）的笔记，欢迎参考！
【线索二叉树】C++代码及线索化过程详解
z135733的博客
05-23 1309
不含头结点的线索二叉树详解~快来看看吧！
C++线索二叉树（中序线索二叉树及遍历）
qq_58240448的博客
07-10 3307
使用c++实现的线索二叉树及其中序遍历
线索二叉树_线索二叉树_
10-01
在C++中实现线索二叉树，首先需要定义一个新的二叉树节点结构，包含三个指针：`lchild`（左孩子），`rchild`（右孩子），以及两个新的线索指针`ltag`和`rtag`。`ltag`和`rtag`用于标记原左、右孩子指针是否为线索。...
C++线索二叉树类实现
07-26
在C++中实现线索二叉树需要理解二叉树的基本概念以及链式存储结构。本文将深入探讨线索二叉树的原理和C++实现。 首先，我们要明确二叉树的基本概念。二叉树是由n（n>=0）个有限节点组成的数据结构，这些节点通过边...
C/C++数据结构实现二叉树的遍历与线索二叉树
12-26
使用C/C++实现二叉树的构造、先序遍历、中序遍历、后序遍历、中序线索化、线索化后的中序遍历等基本树操作。
[Leetcode] 一文玩转二叉树的遍历
chinanfsk的博客
06-25 211
二叉树的前序，中序，后序，递归与非递归遍历 二叉树的层序遍历，层序逐层输出遍历 public class TraverseBinaryTree { /** Traverse a binary tree recursively */ public List<Integer> traverseRecursive(TreeNode root, Type type) { Lis...
【数据结构初阶】排序算法(中)快速排序专题
fhvyxyci的博客
09-28 1194
1. 快排主框架 2. 快排的不同实现 2. 1 hoare版本 2. 2 挖坑法 2. 3 lomuto前后指针法 2. 4 快排的非递归版本 3. 快排优化 3. 1 快排性能的关键点分析: 3. 1 三路划分 3. 2 introsort自省排序
C~排序算法
weixin_60461563的博客
09-27 1109
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
数据结构-3.10.队列的应用
最新发布
ADCvbV的博客
10-01 144
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
线索二叉树概念与C++实现解析
"这篇文档是关于数据结构课程中线索二叉树的概念及其C++实现的上课笔记，包含2020年5月12日的课程内容。文档提供了三种二叉树序列化的问题示例，并详细解释了线索二叉树的动机、存储结构以及C++实现线索二叉树的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值