【C++实现二叉树的链式存储】

最新推荐文章于 2024-08-24 08:38:37 发布
最新推荐文章于 2024-08-24 08:38:37 发布
阅读量882 收藏 4
点赞数
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63184211/article/details/128883640
版权
本文详细介绍了如何使用C++实现链式存储的二叉树，包括节点定义、二叉树结构、构造与析构函数，以及各种遍历（前序、中序、后序、层序）和辅助操作（节点计数、高度计算、查找、拷贝等）。此外，还探讨了非递归遍历方法和通过遍历序列创建二叉树的方法。
摘要由CSDN通过智能技术生成

C++实现二叉树的链式存储

二叉树链式存储的常用操作及实现代码

1.节点标记

enum ECCHILDSIGN//节点标记
{
   
	E_Root,//树根
	E_ChildLeft,//左孩子
	E_ChildRight//右孩子
};

2.树中每个节点的定义

//树中每个节点的定义
template <typename T>//T代表数据的类型
struct BinaryTreeNode
{
   
	T data;//数据域
	BinaryTreeNode* leftChild;//左孩子节点指针
	BinaryTreeNode* rightChild;//右孩子节点指针
	//BinaryTreeNode* parent;//父节点指针，根据需要可以引入
};

3.二叉树的定义

//二叉树的定义
template <typename T>
class BinaryTree
{
   
public:
	BinaryTree();//构造函数
	~BinaryTree();//析构函数
	//创建一个树节点
	BinaryTreeNode<T>* CreateNode(BinaryTreeNode<T>* parent, ECCHILDSIGN pointsign, const T& e);
	//释放一个树节点
	void RleaseNode(BinaryTreeNode<T>* pnode);
	//利用扩展二叉树的前序遍历序列来创建一棵二叉树
	void CreateBiTreeAccordPT(char* pstr); 
	void preOrder();//前序遍历
	void inOrder();//中序遍历
	void postOrder();//后序遍历
	void levelOrder();//层序遍历
	//求二叉树节点个数
	int getSize();
	//求二叉树高度
	int getHeight();
	//查找某个节点（假设二叉树的节点各不相同）
	BinaryTreeNode<T>* SearchElem(const T& e);
	//查找某个节点的父节点
	BinaryTreeNode<T>* GetParent(BinaryTreeNode<T>* tSonNode);
	//树的拷贝
	void CopyTree(BinaryTree<T>* targettree);
	//非递归方式前序遍历二叉树
	void preOrder_noRecu();
	//非递归方式中序遍历二叉树
	void inOrder_noRecu();
	//非递归方式后序遍历二叉树
	void postOrder_noRecu();
	//根据前序和中序遍历序列来创建二叉树
	void CreateBTreeAccordPI(char *pP_T,char *pI_T);
	//根据后序和中序遍历序列来创建二叉树
	void CreateBTreeAccordPO(char* pP_T, char* pI_T);
private:
	BinaryTreeNode<T>* root;//树根节点的指针
	//利用扩展二叉树的前序遍历序列创建二叉树的递归函数
	void CreateBiTreeAccordPTRecu(BinaryTreeNode<T>*& tnode,char* &pstr);//参数类型为引用，确保递归调用中对参数的改变会影响到调用值
	void preOrder(BinaryTreeNode<T>* tNode);//前序遍历
	void inOrder(BinaryTreeNode<T>* tNode);//中序遍历
	void postOrder(BinaryTreeNode<T>* tNode);//后序遍历
	void levelOrder(BinaryTreeNode<T>* tNode);//层序遍历
	//求二叉树节点个数
	int getSize(BinaryTreeNode<T>* tNode);//也可以用遍历二叉树的方式求节点个数
	//求二叉树高度
	int getHeight(BinaryTreeNode<T>* tNode);
	//查找某个节点（假设二叉树的节点各不相同）
	BinaryTreeNode<T>* SearchElem(BinaryTreeNode<T>* tNode, const T& e);
	//树的拷贝
	void CopyTree(BinaryTreeNode<T>* tSouce, BinaryTreeNode<T>*& tTarget);//注意第二个参数类型引用
	//非递归方式前序遍历二叉树
	void preOrder_noRecu(BinaryTreeNode<T>* tNode);
	//非递归方式中序遍历二叉树
	void inOrder_noRecu(BinaryTreeNode<T>* tNode);
	//非递归方式后序遍历二叉树
	void postOrder_noRecu(BinaryTreeNode<T>* tNode);
	//根据前序和中序遍历序列来创建二叉树
	void CreateBTreeAccordPI(BinaryTreeNode<T>* &tNode, char* pP_T, char* pI_T, int n);
	//根据后序和中序遍历序列来创建二叉树
	void CreateBTreeAccordPO(BinaryTreeNode<T>*& tNode, char* pP_T, char* pI_T, int n);
};

4.构造函数和析构函数

//构造函数
template<typename T>
BinaryTree<T>::BinaryTree()
{
   
	root = nullptr;//设置为空树
}
//析构函数
template<typename T>
BinaryTree<T>::~BinaryTree()
{
   
	RleaseNode(root);//从根开始释放节点
}

5.释放二叉树节点操作

template <typename T>
void BinaryTree<T>::RleaseNode(BinaryTreeNode<T>* pnode)
{
   
	if (pnode != nullptr)
	{
   
		RleaseNode(pnode->leftChild);//释放它的左孩子
		RleaseNode(pnode->rightChild);//释放它的右孩子
	}
	delete pnode;
}

6.创建一个树节点

enum ECCHILDSIGN//节点标记
{
   
	E_Root,//树根
	E_ChildLeft,//左孩子
	E_ChildRight//右孩子
};

7.利用扩展二叉树的前序遍历序列来创建一棵二叉树

//利用扩展二叉树的前序遍历序列来创建一棵二叉树
template <typename T>
void BinaryTree<T>::CreateBiTreeAccordPT(char* pstr)
{
   
	CreateBiTreeAccordPTRecu(root, pstr);
}
//利用扩展二叉树的前序遍历序列创建二叉树的递归函数
template <typename T>
void BinaryTree<T>::CreateBiTreeAccordPTRecu(BinaryTreeNode<T>*& tnode, char*& pstr)//参数类型为引用，确保递归
{
   
	//ABD###C#B##
	if (*pstr == '#')
	{
   
		tnode = nullptr;
	}
	else
	{
   
		//根左右
		tnode = new BinaryTreeNode<T>;//创建新节点
		tnode->data = *pstr;
		CreateBiTreeAccordPTRecu(tnode->leftChild, ++pstr);//创建左子树
		CreateBiTreeAccordPTRecu(tnode->rightChild, ++pstr);//创建右子树
	}
}

8.遍历操作

（1）前序遍历二叉树

//前序遍历二叉树
//根左右
template <typename T>
void BinaryTree<T>::preOrder()
{
   
	preOrder(root);
}
template <typename T>
void BinaryTree<T>::preOrder(BinaryTreeNode<T>* tNode)
{
   
	if (tNode != nullptr)//不是空二叉树
	{
   
		cout << tNode->data << " ";//输出节点的数据域值
		preOrder(tNode->leftChild);//递归方式前序遍历左子树
		preOrder(tNode->rightChild);//递归方式前序遍历右子树
	}
}

（2）中序遍历二叉树

//中序遍历二叉树
//左根右
template <typename T>
void BinaryTree<T>::inOrder()
{
   
	inOrder(root);
}
template <typename T>
void BinaryTree<T>::inOrder(BinaryTreeNode<T>* tNode)
{
   
	if (tNode != nullptr)//不是空二叉树
	{
   
		inOrder(tNode->leftChild);//递归方式中序遍历左子树
		cout << tNode->data << " ";//输出节点的数据域
		inOrder(tNode->rightChild);//递归方式中序遍历右子树
	}
}

（3）后序遍历二叉树

//后序遍历二叉树
//左右根
template <typename T>
void BinaryTree<T>::postOrder()
{
   
	postOrder(root);
}
template <typename T>
void BinaryTree<T>::postOrder(BinaryTreeNode<T>* tNode)
{
   
	if (tNode != nullptr)//不是空二叉树
	{
   
		postOrder(tNode->leftChild);//递归方式后序遍历左子树
		postOrder(tNode->rightChild);//递归方式后序遍历右子树
		cout << tNode->data << " ";//输出节点的数据域
	}
}

（4）层序遍历二叉树（使用队列实现）

类模板队列代码

//带头结点的实现方式
//定义节点
template <typename T>
struct QueueNode
{
   
	T data;//数据域
	QueueNode<T>* next;//存放下一个节点的指针
};
template <typename T>
class LinkQueue
{
   
public:
	LinkQueue();//构造函数
	~LinkQueue();//析构函数
	bool EnQueue(const T& e);//入队函数
	bool DeQueue(T& e);//出队函数
	bool GetQueue(T& e);//获取队尾元素
	bool Empty();//判断是否为空队列
	int Queue();//返回队列长度
	void DisplayQueue();//扫描队列
	void ClearQueue();//清空队列
private:
	QueueNode<T>* m_front;//队首
	QueueNode<T>* m_rear;//队尾
	int m_size;//队列长度
	QueueNode<T>* m_head;//头节点
};
template <typename T>
LinkQueue<T>::LinkQueue()
{
   
	QueueNode<T>* m_head = new QueueNode<T>;//新建一个头结点
	m_front = nullptr;
	m_rear = nullptr;
	m_head->next = m_front;
	m_size = 0;
}
template <typename T>
LinkQueue<T>::~LinkQueue()
{
   
	T k;
	while (m_size > 0)
	{
   
		DeQueue(k);
	}//释放队列
	delete m_head;//释放队首
}
template <typename T>
bool LinkQueue<T>::EnQueue(const T& e)
{
   
	QueueNode<T>* p = new QueueNode<T>;//为新的头结点分配空间
	p->data = e;//传入数据域
	if (m_size == 0)
	{
   
		m_rear = p;//将新节点的指针传入队尾
		m_front = p;//将新节点的指针传入队首
		m_size++;//队列长度增加
		return true;
	}
	if (m_size == 1)
	{
   
		m_rear = p;//将新节点的指针传入队头
		m_front->next = m_rear;//将m_rear设为m_front的后继节点
		m_size++;//队列长度增加
		return true;
	}
	else
	{
   
		QueueNode<T>* q = m_rear;//新建节点来接受队尾的值
		q->next = p;//将新节点插入在旧队尾的后面
		m_rear = p;//更新队尾
		m_size++;//队列长度增加
		return true;
	}
}
template <typename T>
bool LinkQueue<T>::DeQueue(T& e)
{
   
	if (m_size == 0)
	{
   
		cout << "空队列无法出队！" << endl;
		return false;
	}
	if (m_size == 1)
	{
   
		e = m_front->data;//获取队头数据
		QueueNode<T>* p = m_front;//获取队头指针
		delete p;//释放队尾
		m_rear = nullptr;
		m_front = nullptr;
		m_size--;//队列长度减少
		return true;
	}
	else
	{
   
		e = m_front->data;//获取队头数据
		QueueNode<T>* p = m_front;//获取队头指针
		m_front = p->next;//队头后移
		delete p;//释放队头
		m_size--;//队列长度减少
		return true;
	}
}
template <typename T>
bool LinkQueue<T>::GetQueue(T& e)
{
   
	if (m_size == 0)
	{
   
		cout << "空队列无法获取队尾元素！" << endl;
		return false;
	}
	else
	{
   
		e = m_front->data;//获取队尾数据
		return true;
	}
}
template <typename T>
bool LinkQueue<T>::Empty()
{
   
	if (m_size == 0)
	{
   
		return true;
	}
	else
	{
   
		return false;
	}
}
template <typename T>
int LinkQueue<T>::Queue()
{
   
	return m_size;
}
template <typename T>
void LinkQueue<T>::DisplayQueue()
{
   
	if (m_size == 0)
	{
   
		cout << "空队列，无法扫描！" << endl;
	}
	else
	{
   
		QueueNode<T>* p = m_front;
		for (int i = 0; i < m_size; i++)
		{
   
			cout << p->data << " ";
			p = p->next;
		}//从头扫描队列
		cout << endl;//换行
	}
}
template <typename T>
void LinkQueue<T>::ClearQueue()
{
   
	T k;
	while (m_size > 0)
	{
   
		DeQueue(k);
	}//释放队列
	delete m_head;//释放队首
}

层序遍历实现代码

//层序遍历二叉树
template <typename T>
void BinaryTree<T>::levelOrder()
{
   
	levelOrder(root);
}
template <typename T>
void BinaryTree<T>::levelOrder(BinaryTreeNode<T>* tNode)
{
   
	if (tNode != nullptr)//若二叉树非空
	{
   
		BinaryTreeNode<T>* tmpnode;
		LinkQueue<BinaryTreeNode<T>* > lnobj;//注意队列元素类型是节点指针类型
		lnobj.EnQueue(tNode);//先把根节点指针入队
		while (!lnobj.Empty())//循环判断队列是否为空
		{
   
			lnobj.DeQueue(tmpnode);//出队列
			cout << (char)tmpnode->data << " ";
			if (tmpnode->leftChild != nullptr)
			{
   
				lnobj.EnQueue(tmpnode->leftChild);//左孩子入队
			}
			if (tmpnode->rightChild != nullptr)
			{
   
				lnobj.EnQueue(tmpnode->rightChild);//右孩子入队
			}
		}//end while
	}// end if
}

10.结合队列实现前序、中序、后序、层序遍历的链式二叉树实现代码

#include <iostream>
using namespace std;
//带头结点的实现方式
//定义节点
template <typename T>
struct QueueNode
{
   
	T data;//数据域
	QueueNode<T>* next;//存放下一个节点的指针
};
template <typename T>
class LinkQueue
{
   
public:
	LinkQueue();//构造函数
	~LinkQueue();//析构函数
	bool EnQueue(const T& e);//入队函数
	bool DeQueue(T& e);//出队函数
	bool GetQueue(T& e);//获取队尾元素
	bool Empty();//判断是否为空队列
	int Queue();//返回队列长度
	void DisplayQueue();//扫描队列
	void ClearQueue();//清空队列
private:
	QueueNode<T>* m_front;//队首
	QueueNode<T>* m_rear;//队尾
	int m_size;//队列长度
	QueueNode<T>* m_head;//头节点
};
template <typename T>
LinkQueue<T>::LinkQueue()
{
   
	QueueNode<T>* m_head = new QueueNode<T>;//新建一个头结点
	m_front = nullptr;
	m_rear = nullptr;
	m_head->next = m_front;
	m_size = 0;
}
template <typename T>
LinkQueue<T>::~LinkQueue()
{
   
	T k;
	while (m_size > 0)
	{
   
		DeQueue(k);
	}//释放队列
	delete m_head;//释放队首
}
template <typename T>
bool LinkQueue<T>::EnQueue(const T& e)
{
   
	QueueNode<T>* p = new QueueNode<T>;//为新的头结点分配空间
	p->data = e;//传入数据域
	if (m_size == 0)
	{
   
		m_rear = p;//将新节点的指针传入队尾
		m_front = p;//将新节点的指针传入队首
		m_size++;//队列长度增加
		return true;
	}
	if (m_size == 1)
	{
   
		m_rear = p;//将新节点的指针传入队头
		m_front->next = m_rear;//将m_rear设为m_front的后继节点
		m_size++;//队列长度增加
		return true;
	}
	else
	{
   
		QueueNode<T>* q = m_rear;//新建节点来接受队尾的值
		q->next = p;//将新节点插入在旧队尾的后面
		m_rear = p;//更新队尾
		m_size++;//队列长度增加
		return true;
	}
}
template <typename T>
bool LinkQueue<T>::DeQueue(T& e)
{
   
	if (m_size == 0)
	{
   
		cout << "空队列无法出队！" << endl;
		return false;
	}
	if (m_size == 1)
	{
   
		e = m_front->data;//获取队头数据
		QueueNode<T>* p = m_front;//获取队头指针
		delete p;//释放队尾
		m_rear = nullptr;
		m_front = nullptr;
		m_size--;//队列长度减少
		return true;
	}
	else
	{
   
		e = m_front->data;//获取队头数据
		QueueNode<T>* p = m_front;//获取队头指针
		m_front = p->next;//队头后移
		delete p;//释放队头
		m_size--;//队列长度减少
		return true;
	}
}
template <typename T>
bool LinkQueue<T>::GetQueue(T& e)
{
   
	if (m_size == 0)
	{
   
		cout << "空队列无法获取队尾元素！" << endl;
		return false;
	}
	else
	{
   
		e = m_front->data;//获取队尾数据
		return true;
	}
}
template <typename T>
bool LinkQueue<T>::Empty()
{
   
	if (m_size == 0)
	{
   
		return true;
	}
	else
	{
   
		return false;
	}
}
template <typename T>
int LinkQueue<T>::Queue()
{
   
	return m_size;
}
template <typename T>
void LinkQueue<T>::DisplayQueue()
{
   
	if (m_size == 0)
	{
   
		cout << "空队列，无法扫描！" << endl;
	}
	else
	{
   
		QueueNode<T>* p = m_front;
		for (int i = 0; i < m_size; i++)
		{
   
			cout << p->data << " ";
			p = p->next;
		}//从头扫描队列
		cout << endl;//换行
	}
}
template <typename T>
void LinkQueue<T>::ClearQueue()
{
   
	T k;
	while (m_size > 0)
	{
   
		DeQueue(k);
	}//释放队列
	delete m_head;//释放队首
}
enum ECCHILDSIGN//节点标记
{
   
	E_Root,//树根
	E_ChildLeft,//左孩子
	E_ChildRight//右孩子
};
//树中每个节点的定义
template <typename T>//T代表数据的类型
struct BinaryTreeNode
{
   
	T data;//数据域
	BinaryTreeNode* leftChild;//左孩子节点指针
	BinaryTreeNode* rightChild;//右孩子节点指针
	//BinaryTreeNode* parent;//父节点指针，根据需要可以引入
};
//二叉树的定义
template <typename T>
class BinaryTree
{
   
public:
	BinaryTree();//构造函数
	~BinaryTree();//析构函数
	//创建一个树节点
	BinaryTreeNode<T>* CreateNode(BinaryTreeNode<T>* parent, ECCHILDSIGN pointsign, const T& e);
	//释放一个树节点
	void RleaseNode(BinaryTreeNode<T>* pnode);
	//利用扩展二叉树的前序遍历序列来创建一棵二叉树
	void CreateBiTreeAccordPT(char* pstr); 
	void preOrder();//前序遍历
	void inOrder();//中序遍历
	void postOrder();//后序遍历
	void levelOrder();//层序遍历
private:
	BinaryTreeNode<T>* root;//树根节点的指针
	//利用扩展二叉树的前序遍历序列创建二叉树的递归函数
	void CreateBiTreeAccordPTRecu(BinaryTreeNode<T>*& tnode,char* &pstr);//参数类型为引用，确保递归调用中对参数的改变会影响到调用值
	void preOrder(BinaryTreeNode<T>* tNode);//前序遍历
	void inOrder(BinaryTreeNode<T>* tNode);//中序遍历
	void postOrder(BinaryTreeNode<T>* tNode);//后序遍历
	void levelOrder(BinaryTreeNode<T>* tNode);//层序遍历
};
//构造函数
template<typename T>
BinaryTree<T>::BinaryTree()
{
   
	root = nullptr;//设置为空树
}
//析构函数
template<typename T>
BinaryTree<T>::~BinaryTree()
{
   
	RleaseNode(root);//从根开始释放节点
}
//释放二叉树节点
template <typename T>
void BinaryTree<T>::RleaseNode(BinaryTreeNode<T>* pnode)
{
   
	if (pnode != nullptr)
	{
   
		RleaseNode(pnode->leftChild);//释放它的左孩子
		RleaseNode(pnode->rightChild);//释放它的右孩子
	}
	delete pnode;
}
//创建一个树节点
template <typename T>
BinaryTreeNode<T>* BinaryTree<T>::CreateNode(BinaryTreeNode<T>* parentnode, ECCHILDSIGN pointsign, const T& e)
{
   
	//将新节点创建出来
	BinaryTreeNode<T>* tmpnode = new BinaryTreeNode<T>;
	tmpnode->data = e;//给新节点传入数据
	tmpnode->leftChild = nullptr;
	tmpnode->rightChild = nullptr;
	//把新节点放入正确的位置
	if (pointsign == E_Root)//创建的是树根节点
	{
   
		root = tmpnode;
	}
	if (pointsign == E_ChildLeft)//创建的是左孩子
	{
   
		parentnode->lef
最低0.47元/天 解锁文章
B-Bro
关注
数据结构(C++) - 实现二叉树链式存储结构
指尖上跳转
09-08 1361
#pragma once #include <iostream> using namespace std; template <typename DataType> struct BinTreeNode { DataType data; BinTreeNode* lChild; BinTreeNode* rChild; }; // 二叉树 template <class DataType> class BinTree { public: BinTree()
C++链式存储实现二叉树（附源代码）
A Lucky Boy的博客
02-02 398
C++链式存储实现二叉树（附源代码）
二叉树（链式存储）—— C++实现
浪子花梦
12-21 3108
作者：花 梦 时间：2019.12.21 二叉树（链式存储） 非线性 物理上不连在一起 树型结构 直接开撸，首先需要我们的头文件与命名空间： #include <iostream> #include <deque> // 下面的层级遍历的算法需要用到队列 using namespace std; 链式存储需要结点来连接左子树与右子树： template &...
链式二叉树C++（附带可执行源码）
xiawubushangban的博客
04-09 416
于线性表的（一个节点只有一个直接前驱和一个直接后继），树是的一种数据结构。（一个节点对应多个直接后继）。由于n叉树在实现过程中其分叉数目不定，而n叉树的问题大多可以化解成二叉树来理解，所以二叉树是重点研究对象。链式二叉树是二叉树的一种存储形式，它的操作更加简单灵活，便于对于二叉树中的节点进行增删。
二叉树的链式存储（代码实现）
最新发布
2301_77143270的博客
08-24 613
若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。(2) 在森林中选出两个根结点的权值最小的树合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和；(4)重复(2)、(3)步，直到森林中只剩一棵树为止，该树即为所求得的哈夫曼树。层次遍历（补充了解）
二叉树的二叉链表存储结构及C++实现
weixin_34268843的博客
12-29 1145
前言：存储二叉树的关键是如何表示结点之间的逻辑关系，也就是双亲和孩子之间的关系。在具体应用中，可能要求从任一结点能直接访问到它的孩子。 一、二叉链表 　　二叉树一般多采用二叉链表（binary linked list）存储，其基本思想是：令二叉树的每一个结点对应一个链表结点链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。二叉链表的结点结构如下图所示： 二叉树结点结构...
树和二叉树的存储结构的实现(C/C++实现)
weixin_34378922的博客
11-12 267
存档： 1 #include &lt;iostream.h&gt; 2 #include &lt;stdio.h&gt; 3 #include &lt;stdlib.h&gt; 4 #define max 20 5 typedef char elemtype; 6 #include "tree.h" 7 void main() 8 { 9 btree...
C/C++数据结构（九） —— 链式二叉树
Edison's 小宇宙
11-05 2396
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系，比如双亲与孩子的关系，左右兄弟的关系等。
C++实现二叉树（链式存储）
11-29
这是我用C++实现的二叉树，感觉思路还是不错的！！
C++实现二叉树的链式存储及三种递归遍历
qq_46027243的博客
02-18 349
文章目录 #include<iostream> #include<queue> #include<stack> using namespace std; #define MaxSize 100 typedef struct TreeNode { int data; TreeNode* left; TreeNode* right; TreeNode() { data = 0; //数据域 left = NULL; right = NULL; }
使用C++链表来实现二叉树的存储和基本操作
Lavi的专栏
10-07 3877
1、创建Node.h 定义链表的节点 #ifndef NODE_H #define NODE_H class Node{ public: Node(); Node* searchNode(int nodeIndex); void delNode(); void preOrderTraverse(); void midOrderTraverse();
C++ 二叉树链式存储 按层遍历 输出叶子 左右树交换 实例 源文件
11-24
1．对给定二叉树用链式链式存储结构；利用队列与栈对二叉树进行运算。 2．按层次输出所有结点。 3．输出所有叶子结点。 4．将所有左右子树值交换。
链式结构存储二叉树的基本操作
09-01
采用链式结构存放二叉树，实现二叉数的创建，实现二叉数的遍历（前序，后序，中序层次遍历），分别求二叉树的叶子结点和结点的数目，二叉树的查找，二叉树的深度。
C++数组实现二叉树的存储及基本操作
10-06
数据结构之使用C++语言中的数组实现二叉树的存储及其基本操作
C++实现 链表存储二叉树
weixin_43335392的博客
03-27 2300
前言：国内很多教材，讲完二叉树的结构，就直接开始讲二叉树的遍历，我就觉得很奇怪，你连个完整的二叉树都没创建，遍历什么，于是我写了下面这篇文章，详细介绍了创建过程，然后再说遍历，循序渐进 1.什么是二叉树？什么是完美二叉树和完全二叉树？ 直接上图 可以看到，图中的根结点拥有左右两个结点，同时左右两个结点，又是一棵独立的、互不相交的树，分别称为左子树、右子树，这就是二叉树名字的由来 完美二叉树：又...
二叉树的存储与c++描述
SuperYang_的博客
01-31 827
文章中部分内容和思路来自《数据结构、算法与应用 c++语言描述》 接续上一篇文章《树 & 二叉树基本概念》:http://blog.csdn.net/superyang_/article/details/79204902 数组描述 将要表示的二叉树看做缺少部分元素的完全二叉树，如图： 链表描述 每个节点/元素有两个指针域，分别指
C++实现链式存储线索二叉树
m0_51955470的博客
03-10 313
一颗线索二叉树： 根据下图进行节点的创建： 代码如下： #include <iostream> using namespace std; typedef char ElemType; typedef struct BiThrNode { ElemType data; int ltag,rtag; struct BiThrNode *lchild,*rchild; }BiThrNode,*BiThrTree; 1、二叉树的线索化，实质上就是遍历一棵二叉树，在遍历过程中，访问节点的操作
二叉树的链式存储与实现（C++）
tongxinhaonan的专栏
05-24 2897
二叉链表存储结构的类型定义如下：
C++二叉树的链式存储结构_1
TianKelly的博客
09-07 304
二叉树的链式存储结构物理模型： class Bnode { public: int data; Bnode* left_node; Bnode* right_node; }; 和双链表的定义非常类似。当链二叉树的结点个数为n时，一共有n-1个非空指针域，n+1个空指针域，一共有2n个指针域。 链式三叉树，再指针域定义时，多加一个指向双亲结点的指针 class TriBiTreenode { public: int data; TriBiTreenode* left_node; T
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值