【高阶数据结构】二叉树的创建、存储方式（顺序与链式）、遍历方法(递归与非递归)（精美图解+完整代码）

于 2024-09-03 10:37:58 发布
阅读量1k 收藏 19
点赞数 16
分类专栏： 《高阶数据结构》 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43382136/article/details/140068971
版权

🤡博客主页：醉竺

🥰本文专栏：《高阶数据结构》

😻欢迎关注：感谢大家的点赞评论+关注，祝您学有所成！

✨✨💜💛想要学习更多《高阶数据结构》点击专栏链接查看💛💜✨✨ 

目录

1. 顺序存储方式

2. 链式存储方式 

3. 顺序存储的常用操作代码实现

3.1 树中每个节点的定义

 3.2 二叉树的定义

3.2.1 二叉树各种接口的实现 

3.2.2 二叉树顺序存储测试

4. 链式存储的常用操作代码实现

2.1 类定义、初始化和释放

2.2 创建树节点

2.3 二叉树常用操作

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

2.5 递归遍历二叉树

1. 前序遍历

 2. 中序遍历

3. 后序遍历

4. 层序遍历 

2.6 非递归遍历二叉树

1. 前序遍历（根左右）

2. 中序遍历（左根右）  

3. 后序遍历（左右根）

 2.7 通过遍历序列创建二叉树

1. 根据前序和中序遍历创建二叉树

2. 根据中序和后序遍历创建二叉树 

5. 小结

如果对二叉树还不是了解的同学，可以先简单学习一下下面一篇文章，详细讲解了二叉树的相关概念和性质证明，以及遍历方法： 

《二叉树的概念和性质》icon-default.png?t=N7T8https://blog.csdn.net/weixin_43382136/article/details/136593735?spm=1001.2014.3001.5502《二叉树的深度优先遍历和广度优先遍历》icon-default.png?t=N7T8https://blog.csdn.net/weixin_43382136/article/details/136658468?spm=1001.2014.3001.5502

学完本章，你将掌握：

  1. 二叉树顺序存储代码实现；
  2. 二叉树链式存储代码实现；
  3. 二叉树的前序遍历、中序遍历、后序遍历的递归实现和非递归实现；
  4. 通过前序和中序遍历序列创建二叉树；
  5. 通过中序和后序遍历序列创建二叉树；
  6. 二叉树的其他操作。 

二叉树的存储一般有两种方式，一种是基于数组的 顺序 存储方式，一种是 链式 存储方式。它们有什么不同呢？

1. 顺序存储方式

顺序存储方式是用一段连续的内存单元（数组）依次从上到下、从左到右存储二叉树各个节点元素。

假设我们存储的是一棵完全二叉树，如果把根节点存储在数组中下标i = 1的位置，那么根据之前讲解的二叉树编号规律，左子节点就存储在下标2 * i = 2的位置，右子节点就存储在2 * i + 1 = 3的位置。这样就可以通过下标把整棵树串起来。  

因为节点编号从1开始，所以数组中下标为0的位置可以空出来不用，让数组下标和节点编号保持一致。虽然这样浪费了一个存储空间，不过这点你可以自由决定。  

参考下图1。  

不难看到，数组的下标可以体现出节点的存储位置。换句话说，数组的下标能够体现出节点之间的逻辑关系（父子、兄弟）。

但如果存储的不是一棵完全二叉树，而是普通二叉树，那么存储的时候，也需要将其按照完全二叉树的方式来编号存储，这样肯定会浪费较多的数组存储空间。

参考下图2。

图2中虚线表示的节点表示不存在的节点，但在存储时却要给其留出位置。可以看到，下标6、8的数组空间都被浪费掉了。

你可以想一种极端的情况：如果有一棵深度为4的右斜树需要保存，会浪费多少个数组空间呢？

根据二叉树性质2，“高度为k的二叉树至多有2^{k}-1个节点”，存储高度为 4 的二叉树，最坏情况下空间需求是2^{4}-1=15，因为下标为0的空间不使用，所以最坏情况下空间需求是2^{4}=16，而图3的右斜树恰恰需要2^{4}=16个存储空间。即便下标为0的位置不计算在内，也整整浪费了11个位置。

可是，完全二叉树就不会存在这个问题。这就是完全二叉树最后一层叶节点都靠左侧排列这种硬性规定所带来的存储益处。换句话说， 顺序存储结构一般是用于存储完全二叉树。

2. 链式存储方式 

链式存储方式要存储额外的左右子节点的指针，而顺序存储方式是不需要指针的，所以通常来讲， 链式存储方式多用于存储普通的二叉树。

链式存储中，二叉树的每个节点最多有两个子节点，所以为每个节点设计结构时一般都包括一个数据域和两个指针域，分别指向左孩子节点和右孩子节点。至于没有用到的指针，设置为nullptr即可。结构示意图如图4所示：

从图4可以看到，只要 拎住最上面的根节点，就可以通过左右子节点的指针把整棵树串起来。

利用这种节点结构所得到的二叉树存储结构，叫做 二叉链表，一个节点结构中带两个指针。有时候为了方便找到某个节点的父节点，还可以在设计节点结构的时候再增加一个指针，用于指向其父节点，这种节点结构所得到的二叉树存储结构，就叫做 三叉链表，也就是一个节点结构中带三个指针。

3. 顺序存储的常用操作代码实现

概念理清之后，我们就要开始代码层面的学习了。虽然顺序存储结构一般是用于存储完全二叉树，但为了让写出的代码也支持普通二叉树，所以我会用二叉树的顺序存储方式，存储图5左侧所示的普通二叉树。  

下面是顺序存储代码的完整实现每一部分都有详细注释。 

BinaryTree_Seq.h

3.1 树中每个节点的定义

#include <iostream>
using namespace std;

#define MaxSize 100       //数组的尺寸

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

//树中每个节点的定义
template <typename T>//T代表数据元素的类型
struct BinaryTreeNode
{
	T        data;   //数据域，存放数据元素
	bool     isValid;//该节点是否有效以应对非完全二叉树（只有保存了实际节点数据的节点才是有效的）
};

 3.2 二叉树的定义

//二叉树的定义
template <typename T>
class BinaryTree
{
private:
	BinaryTreeNode<T> SqBiTree[MaxSize + 1]; //存储二叉树节点的数组，为写程序方便，下标为[0]的数组元素不使用，因此这里+1

private:
	bool ifValidRangeIdx(int index) //是否是一个有效的数组下标值
	{
		//位置必须合理
		if (index < 1 || index> MaxSize)  //[0]下标留着不用。因定义数组时定义的是MaxSize + 1，所以数组最大下标是MaxSize。
			return false;
		return true;
	}

	//前序遍历二叉树，其他的遍历方式在二叉树的链式存储中再详细书写代码和讲解
	void preOrder(int index)
	{
		if (ifValidRangeIdx(index) == false) //位置不合理
			return;

		if (SqBiTree[index].isValid == false) //不是个合理的节点
			return;

		//根左右顺序	
		cout << (char)SqBiTree[index].data << ""; //输出节点的数据域的值，为方便观察，用char以显示字母
		preOrder(2 * index);  //递归方式前序遍历左子树
		preOrder(2 * index + 1); //递归方式前序遍历右子树
	}

public:
	BinaryTree()      //构造函数
	{
		for (int i = 0; i <= MaxSize; ++i) //注意数组的大小是MaxSize+1，所以这里i的终止值没问题
		{
			SqBiTree[i].isValid = false; //开始时节点无效，没保存任何数据
		}
	}
	~BinaryTree() {};     //析构函数

public:
	//创建一个树节点
	int CreateNode(int parindex, ECCHILDSIGN pointSign, const T& e);
	
	int getParentIdx(int sonindex);//获取父节点的下标

	int getPointLevel(int index);//获取某个节点所在的高度：

	int getLevel(); //获取二叉树的深度

	bool ifCompleteBT();//判断是否是个完全二叉树

	void PreOrderTraversal();//前序遍历二叉树，其他的遍历方式在二叉树的链式存储中再详细书写代码和讲解
};

3.2.1 二叉树各种接口的实现 

BinaryTree_Seq.cpp 

#include "BinaryTree_Seq.h"

创建一个树节点：

  • 参数1：父节点所在数组下标；
  • 参数2：标记所创建的是树根、左孩子、右孩子；
  • 参数3：插入的树节点的元素值；
  • 返回值：返回存储位置对应的数组下标，返回-1表示非法下标（执行失败） 
//创建一个树节点
template <typename T>
int BinaryTree<T>::CreateNode(int parindex, ECCHILDSIGN pointSign, const T& e)
{
    //非根节点，则一定是子节点，要求parindex一定要是个合理值
	if (pointSign != E_Root) 
	{
		if (ifValidRangeIdx(parindex) == false) //位置不合理
			return -1;
		if (SqBiTree[parindex].isValid == false) //父节点不可以无效
			return -1;
	}

	int index = -1;
	if (pointSign == E_Root) //根
	{
		index = 1;//根节点固定存储在下标为1的位置。
	}
	else if (pointSign == E_ChildLeft) //左孩子
	{
		//创建的是左孩子节点，节点i的左孩子节点的下标是2i
		index = 2 * parindex;
		if (ifValidRangeIdx(index) == false)
			return -1; //非法下标
	}
	else //右孩子
	{
		//节点i的右孩子节点的下标是2i+1
		index = 2 * parindex + 1;
		if (ifValidRangeIdx(index) == false)
			return -1; //非法下标
	}

	SqBiTree[index].data = e;
	SqBiTree[index].isValid = true; //标记该下标中有有效数据
	return index;
}

获取父节点的下标： 

//获取父节点的下标
template <typename T> 
int BinaryTree<T>::getParentIdx(int sonindex)
{
	if (ifValidRangeIdx(sonindex) == false) //位置不合理
		return -1;

	if (SqBiTree[sonindex].isValid == false) //不是个合理的节点，不要尝试找父节点
		return -1;

	return  int(sonindex / 2);  //i的父节点是（i / 2）向下取整
}

获取某个节点所在的高度： 

//获取某个节点所在的高度：
//根据二叉树性质五：具有n（n > 0）个节点的完全二叉树的高度为⌈log(⁡n + 1)⌉或者⌊log(⁡n)⌋ + 1。这里的对数都是以2为底
template <typename T>
int BinaryTree<T>::getPointLevel(int index)
{
	if (ifValidRangeIdx(index) == false) //位置不合理
		return -1;

	if (SqBiTree[index].isValid == false)//不是个合理的节点，不要尝试找父节点
		return -1;

	//采用公式⌊log(n)⌋ + 1
	int level = int(log(index) / log(2) + 1);//c++中的log（n）函数求的是以e(2.71828)为底的对数值，如果要求以数字m为底的对数值，则需要log(n)/log(m)

	return level;
}

获取二叉树的深度： 

//获取二叉树的深度
template <typename T>
int BinaryTree<T>::getLevel()
{
	if (SqBiTree[1].isValid == false) //没根？
		return 0;

	int i;
	for (i = MaxSize; i >= 1; --i)
	{
		if (SqBiTree[i].isValid == true) //找到最后一个有效节点
			break;
	} //end for
	return getPointLevel(i);
}

判断是否是个完全二叉树： 

//判断是否是个完全二叉树
template <typename T>
bool BinaryTree<T>::ifCompleteBT()
{
	if (SqBiTree[1].isValid == false) //没根？这是二叉树吗？
		return false;

	int i;
	for (i = MaxSize; i >= 1; --i)
	{
		if (SqBiTree[i].isValid == true) //找到最后一个有效节点
			break;
	} //end for

	for (int k = 1; k <= i; ++k)
	{
		if (SqBiTree[k].isValid == false) //所有节点必须都要有效
			return false;
	}
	return true;
}

前序遍历二叉树： 

//前序遍历二叉树，其他的遍历方式在二叉树的链式存储中再详细书写代码和讲解
template <typename T>
void BinaryTree<T>::PreOrderTraversal()
{
	if (SqBiTree[1].isValid == false) //没根？这是二叉树吗？
		return;

	preOrder(1); //根节点的数组下标是1，所以这里把根的下标传递过去
}

3.2.2 二叉树顺序存储测试

Test_BinaryTree_Seq.cpp 

#include "BinaryTree_Seq.cpp"

int main()
{
	BinaryTree<int> mytree;
	//创建一棵二叉树
	int indexRoot = mytree.CreateNode(-1, E_Root, 'A'); //创建树根节点A
	int indexNodeB = mytree.CreateNode(indexRoot, E_ChildLeft, 'B');  //创建树根的左子节点B
	int indexNodeC = mytree.CreateNode(indexRoot, E_ChildRight, 'C'); //创建树根的右子节点C

	int indexNodeD = mytree.CreateNode(indexNodeB, E_ChildLeft, 'D'); //创建节点B的左子节点D
	int indexNodeE = mytree.CreateNode(indexNodeC, E_ChildRight, 'E'); //创建节点C的右子节点E	

	int iParentIndexE = mytree.getParentIdx(indexNodeE);   //获取某个节点的父节点的下标
	cout << "节点E的父节点的下标是：" << iParentIndexE << endl;

	int iLevel = mytree.getPointLevel(indexNodeD);  //获取某个节点所在的高度
	cout << "节点D所在的高度是：" << iLevel << endl;
	iLevel = mytree.getPointLevel(indexNodeE);
	cout << "节点E所在的高度是：" << iLevel << endl;
	cout << "二叉树的深度是：" << mytree.getLevel() << endl;
	cout << "二叉树是个完全二叉树吗？" << mytree.ifCompleteBT() << endl;

	cout << "------------" << endl;
	cout << "前序遍历序列为：";
	mytree.PreOrderTraversal();   //前序遍历

	return 0;
}

4. 链式存储的常用操作代码实现

下面我们熟悉一下二叉树链式存储的常用操作。

2.1 类定义、初始化和释放

#pragma once
#include <iostream>
#include <queue>
#include <stack>
using namespace std;

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

//树中每个节点的定义
template <typename T> //T代表数据元素的类型
struct BinaryTreeNode
{
	T               data;        //数据域，存放数据元素
	BinaryTreeNode* leftChild,   //左子节点指针
		* rightChild;  //右子节点指针

	//BinaryTreeNode* parent;      //父节点指针，可以根据需要决定是否引入
};

//二叉树的定义
template <typename T>
class BinaryTree
{
public:
	BinaryTree();  // 构造函数
	~BinaryTree(); // 析构函数

public:
	//创建一个树节点
	BinaryTreeNode<T>* CreateNode(BinaryTreeNode<T>* parentnode, ECCHILDSIGN pointSign, const T& e);
	//释放树节点
	void ReleaseNode(BinaryTreeNode<T>* pnode);

public:
	int getSize(); //求二叉树节点个数

	int getHeight(); //求二叉树高度（取左右子树中高度更高的）

	//查找某元素节点
	BinaryTreeNode<T>* SearchElem(const T& e);

	//查找父节点
	BinaryTreeNode<T>* GetParent(BinaryTreeNode<T>* tSonNode);

	//树的拷贝
	void CopyTree(BinaryTree<T>* targetTree);

	void preOrder(); //前序遍历二叉树

	void inOrder(); //中序遍历二叉树

	void postOrder(); //后序遍历二叉树

	void levelOrder();//层序遍历二叉树

	void preOrder_noRecu(); //非递归方式前序遍历二叉树

	void inOrder_noRecu(); //非递归方式中序遍历二叉树

	void postOrder_noRecu(); //非递归后序遍历二叉树

	//利用扩展二叉树的前序遍历序列来创建一棵二叉树
	void CreateBTreeAccordPT(char* pstr);

	//如何根据前序、中序遍历序列来创建一棵二叉树呢？	
	//pP_T：前序遍历序列，比如是“ABDCE”，pI_T：中序遍历序列，比如是“DBACE”
	void CreateBTreeAccordPI(char* pP_T, char* pI_T);

	//如何根据中序、后序遍历序列来创建一棵二叉树呢？	
	//pI_T：中序遍历序列，比如是“DBACE”，pPOST_T：后序遍历序列，比如是“DBECA”
	void CreateBTreeAccordIPO(char* pI_T, char* pPOST_T);

private:
	BinaryTreeNode<T>* root; //树根指针	
};

//构造函数
template<class T>
BinaryTree<T>::BinaryTree()
{
	root = nullptr;
}

//析构函数
template<class T>
BinaryTree<T>::~BinaryTree()
{
	ReleaseNode(root);
};

//释放二叉树节点
template<class T>
void BinaryTree<T>::ReleaseNode(BinaryTreeNode<T>* pnode)
{
	if (pnode != nullptr)
	{
		ReleaseNode(pnode->leftChild);
		ReleaseNode(pnode->rightChild);
	}
	delete pnode;
}

2.2 创建树节点

//创建一个树节点
//参数1：父节点指针，参数2：标记所创建的是树根、左孩子、右孩子，参数3：插入的树节点的元素值
template<class 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->leftChild = tmpnode;
	}
	else  if (pointSign == E_ChildRight)
	{
		//创建的是右孩子节点
		parentnode->rightChild = tmpnode;
	}
	return tmpnode;
}

在main主函数中，加入如下代码，创建一个如前面图5左侧所示的一棵二叉树。  

BinaryTree<int> mytree;
//创建一棵二叉树
BinaryTreeNode<int>* rootpoint = mytree.CreateNode(nullptr, E_Root, 'A'); //创建树根节点A
BinaryTreeNode<int>* subpoint = mytree.CreateNode(rootpoint, E_ChildLeft, 'B'); //创建树根的左子节点B
subpoint = mytree.CreateNode(subpoint, E_ChildLeft, 'D'); //创建左子节点B下的左子节点D

subpoint = mytree.CreateNode(rootpoint, E_ChildRight, 'C'); //创建树根的右子节点C
subpoint = mytree.CreateNode(subpoint, E_ChildRight, 'E');  //创建右子节点C下的右子节点E

2.3 二叉树常用操作

接下来，我们将分别实现二叉树的一些常用操作，包括计算节点个数、求二叉树的高度、根据给的节点值查找某个节点、查找某个节点的父节点、二叉树的拷贝。  

  • 计算二叉树的节点个数

//求二叉树节点个数
template <typename T>
int BinaryTree<T>::getSize()
{
	return _getSize(root);
}

template <typename T>
int _getSize(BinaryTreeNode<T>* tNode) //也可以用遍历二叉树的方式求节点个数
{
	if (tNode == nullptr)
		return  0;

	return _getSize(tNode->leftChild) + _getSize(tNode->rightChild) + 1; //之所以+1，是因为还有个根节点
}
  • 求二叉树高度（取左右子树中高度更高的） 
//求二叉树高度（取左右子树中高度更高的）
template <typename T>
int BinaryTree<T>::getHeight()
{
	return _getHeight(root);
}

template <typename T>
int _getHeight(BinaryTreeNode<T>* tNode)
{
	if (tNode == nullptr)
		return  0;
	int lheight = _getHeight(tNode->leftChild); //左子树高度
	int rheight = _getHeight(tNode->rightChild); //右子树高度
	if (lheight > rheight)
		return lheight + 1; //之所以+1，是因为还包括根节点的高度
	return rheight + 1;   //之所以+1，是因为还包括根节点的高度
}

  • 查找某个节点（假设二叉树的节点各不相同）

// 查找某元素节点
template <typename T>
BinaryTreeNode<T>* BinaryTree<T>::SearchElem(const T& e)
{
	return _SearchElem(root, e);
}

template <typename T>
BinaryTreeNode<T>* _SearchElem(BinaryTreeNode<T>* tNode, const T& e)
{
	if (tNode == nullptr)
		return nullptr;
	if (tNode->data == e)  //从根开始找
		return tNode;
	BinaryTreeNode<T>* p = _SearchElem(tNode->leftChild, e); //查找左子树
	if (p != nullptr) //这里的判断不可缺少
		return p;
	return _SearchElem(tNode->rightChild, e); //左子树查不到，继续到右子树查找，这里可以直接return
}

  • 查找某个节点的父节点

//查找某个节点的父节点
template <typename T>
BinaryTreeNode<T>* BinaryTree<T>::GetParent(BinaryTreeNode<T>* tSonNode)
{
	return _GetParent(root, tSonNode);
}

template <typename T>
BinaryTreeNode<T>* _GetParent(BinaryTreeNode<T>* tParNode, BinaryTreeNode<T>* tSonNode)
{
	if (tParNode == nullptr || tSonNode == nullptr)
		return nullptr;

	if (tParNode->leftChild == tSonNode || tParNode->rightChild == tSonNode)
		return tParNode;

	BinaryTreeNode<T>* pl = _GetParent(tParNode->leftChild, tSonNode);
	if (pl != nullptr)
		return pl;

	return  _GetParent(tParNode->rightChild, tSonNode);
}

  • 树的拷贝

CopyTree 函数将一个二叉树（源树）的内容拷贝到另一个二叉树（目标树）中 

//树的拷贝
template <typename T>
void BinaryTree<T>::CopyTree(BinaryTree<T>* targetTree)
{
	_CopyTree(root, targetTree->root);
}

template <typename T>
void _CopyTree(BinaryTreeNode<T>* tSource, BinaryTreeNode<T>*& tTarget) //注意第二个参数类型为引用
{
	if (tSource == nullptr)
	{
		tTarget = nullptr;
	}
	else
	{
		tTarget = new BinaryTreeNode<T>;
		tTarget->data = tSource->data;
		_CopyTree(tSource->leftChild, tTarget->leftChild);  //对左子树进行拷贝
		_CopyTree(tSource->rightChild, tTarget->rightChild);//对右子树进行拷贝
	}
}

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

在前面讲解扩展二叉树时《叉树的深度优先遍历和广度优先遍历》，你已经知道，给出一个扩展二叉树的前序遍历序列，能够唯一确定一棵二叉树。前面图5中右侧的扩展二叉树，其前序遍历序列是“ABD###C#E##”，那么如果想通过这个遍历序列把这棵二叉树创建，是否可以做到呢？可以。  

//利用扩展二叉树的前序遍历序列来创建一棵二叉树
template<class T>
void BinaryTree<T>::CreateBTreeAccordPT(char* pstr)
{
	_CreateBTreeAccordPT(root, pstr);
}

//利用扩展二叉树的前序遍历序列创建二叉树的递归函数
template<class T>
void _CreateBTreeAccordPT(BinaryTreeNode<T>*& tnode, char*& pstr)//参数为引用类型，确保递归调用中对参数的改变会影响到调用者
{
	if (*pstr == '#')
	{
		tnode = nullptr;
	}
	else
	{
		tnode = new BinaryTreeNode<T>; //创建根节点
		tnode->data = *pstr;
		_CreateBTreeAccordPT(tnode->leftChild, ++pstr); //创建左子树
		_CreateBTreeAccordPT(tnode->rightChild, ++pstr);//创建右子树
	}
}

在main主函数中，注释掉以往的代码，新增如下测试代码。  

BinaryTree<int> mytree2;
mytree2.CreateBTreeAccordPT((char *)"ABD###C#E##");

通过跟踪调试，不难看到，上述的mytree2所存储的数据正是图5左侧所示的二叉树。  

2.5 递归遍历二叉树

二叉树创建出来后，就可以通过前面讲解过的遍历方式，将树中各个节点的内容输出出来以方便观察。我们从深度、广度优先遍历两种方式的角度去了解。  

  • 1. 前序遍历

//前序遍历二叉树
template <typename T>
void BinaryTree<T>::preOrder()
{
	_preOrder(root);
}

template <typename T>
void _preOrder(BinaryTreeNode<T>* tNode)
{
	if (tNode != nullptr) //若二叉树非空
	{
		//根左右顺序				
		cout << (char)tNode->data << " "; //输出节点的数据域的值，为方便观察，用char以显示字母
		_preOrder(tNode->leftChild);  //递归方式前序遍历左子树
		_preOrder(tNode->rightChild); //递归方式前序遍历右子树
	}
}

  •  2. 中序遍历

//中序遍历二叉树
template <typename T>
void BinaryTree<T>::inOrder()
{
	_inOrder(root);
}

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

  • 3. 后序遍历

//后序遍历二叉树
template <typename T>
void BinaryTree<T>::postOrder()
{
	_postOrder(root);
}

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

在main主函数中，继续增加如下代码对刚刚创建的树进行前序、中序和后序遍历。  

cout << "前序遍历序列为：";
mytree2.preOrder();   //前序遍历
cout << endl; //换行

cout << "中序遍历序列为：";
mytree2.inOrder();    //中序遍历
cout << endl; //换行

cout << "后序遍历序列为：";
mytree2.postOrder();  //后序遍历

新增代码的执行结果如下，正是对图5左侧所示的二叉树进行前序、中序、后序遍历得到的结果。  

  • 4. 层序遍历 

除了对二叉树进行前序、中序、后序遍历之外，还有一种遍历方式叫层序遍历。前面说过，二叉树的层序遍历需要借助队列来完成，因为难以估计二叉树节点个数，所以使用顺序队列不合适，这里就用链式队列。

//层序遍历二叉树
template <typename T>
void BinaryTree<T>::levelOrder()
{
	_levelOrder(root);
}

template <typename T>
void _levelOrder(BinaryTreeNode<T>* tNode)
{
	if (tNode != nullptr) // 若二叉树非空
	{
		BinaryTreeNode<T>* tmpnode;
		queue<BinaryTreeNode<T>*> q; // 使用STL中的queue容器
		q.push(tNode); // 先把根节点指针入队
		while (!q.empty()) // 循环判断队列是否为空
		{
			tmpnode = q.front(); // 获取队列前端的元素
			q.pop(); // 出队列
			cout << (char)tmpnode->data << " ";
			if (tmpnode->leftChild != nullptr)
				q.push(tmpnode->leftChild);  // 左孩子入队
			if (tmpnode->rightChild != nullptr)     // 右孩子入队
				q.push(tmpnode->rightChild);
		} // end while
	}
}

在main主函数中，继续增加如下代码对刚刚创建的树进行层序遍历。  

cout << endl; //换行
cout << "层序遍历序列为：";
mytree2.levelOrder();

新增代码的执行结果如下。  

这里可以进一步思考一下，如何在上述层序遍历代码中加入一些代码来 判断二叉树是否是一棵完全二叉树 呢？

如果某个节点的左子节点不存在而右子节点存在，那么这棵二叉树就不是完全二叉树，所以上述层序遍历代码中，在出队列一个节点后，可以加入如下代码来判断一棵二叉树是否是完全二叉树。

if(tmpnode->leftChild == nullptr && tmpnode->rightChild != nullptr)
{
	//这棵二叉树不是一棵完全二叉树。
}

上述无论何种遍历方式，每个节点被访问的次数都是有限的，所以遍历操作的时间复杂度和二叉树的节点个数成正比，即二叉树遍历的时间复杂度为O(n)。  

2.6 非递归遍历二叉树

在前面的二叉树遍历代码实现中，除层序遍历外，前序、中序、后序遍历采用的都是递归方式来实现的，这种实现方法代码比较简单。但实际的面试中，有时也会要求采用非递归的方式实现前序、中序、后序遍历，这往往需要借助栈来实现。并且实际的应用中，如果二叉树的高度特别高，节点特别多，用递归的方式遍历可能会导致栈溢出，此时就需要采用非递归方式遍历了。

  • 1. 前序遍历（根左右）

你可以根据图片提示，自己手工绘制一下入栈和出栈的过程，这样也会对通过栈实现前序遍历有一个更深刻的认识。  

//非递归方式前序遍历二叉树
template <typename T>
void BinaryTree<T>::preOrder_noRecu()
{
	_preOrder_noRecu(root);
}

template <typename T>
void _preOrder_noRecu(BinaryTreeNode<T>* tRoot)
{
	if (tRoot == nullptr)
		return;

	stack<BinaryTreeNode<T>*> s;
	s.push(tRoot); // 根节点入栈

	BinaryTreeNode<T>* tmpnode;
	while (!s.empty()) // 栈不空
	{
		tmpnode = s.top(); // 获取栈顶元素
		s.pop(); // 栈顶元素出栈
		cout << (char)tmpnode->data << " "; // 访问栈顶元素

		if (tmpnode->rightChild != nullptr) // 注意先判断右树再判断左树
		{
			s.push(tmpnode->rightChild); // 把右树入栈
		}
		if (tmpnode->leftChild != nullptr)
		{
			s.push(tmpnode->leftChild); // 把左树入栈
		}
	} // end while
}

增加下列测试代码。  

cout << "非递归方式前序遍历序列为：";
mytree2.preOrder_noRecu();
cout << endl;

  • 2. 中序遍历（左根右）  

相应的代码我也放在了下面，不过写法不限于这一种，有兴趣可以发挥自己的想象力，根据“左根右”这个遍历顺序写出不同的非递归遍历代码。  

//非递归方式中序遍历二叉树
template <typename T>
void BinaryTree<T>::inOrder_noRecu()
{
	_inOrder_noRecu(root);
}

template <typename T>
void _inOrder_noRecu(BinaryTreeNode<T>* tRoot)
{
	if (tRoot == nullptr)
		return;

	stack<BinaryTreeNode<T>*> s;
	BinaryTreeNode<T>* tmpnode = tRoot;

	while (tmpnode != nullptr || !s.empty()) {
		while (tmpnode != nullptr) {
			s.push(tmpnode); // 将“当前节点的左节点”入栈
			tmpnode = tmpnode->leftChild; // 将“当前节点的左节点”重新标记为当前节点。
		} //end while

		tmpnode = s.top(); // 对栈顶元素出栈(同时获取了栈顶元素)
		s.pop();
		cout << (char)tmpnode->data << " ";

		// 查看右树
		tmpnode = tmpnode->rightChild;  // 将刚刚从栈顶出栈的元素的右节点标记为当前节点
	}//end while
}

增加下列测试代码。  

cout << "非递归方式中序遍历序列为：";
mytree2.inOrder_noRecu();
cout << endl;

新增代码的执行结果如下。  

  • 3. 后序遍历（左右根）

  1. 初始化：

    • 使用两个栈 s1 和 s2。
    • 将根节点压入 s1 栈。

  2. 遍历过程：

    • 从 s1 栈中弹出一个节点 node。
    • 将 node 压入 s2 栈。
    • 如果 node 有左子节点，将左子节点压入 s1 栈。
    • 如果 node 有右子节点，将右子节点压入 s1 栈。

  3. 输出结果：

    • 当 s1 栈为空时，s2 栈中存储的节点顺序是根节点在最底部，左子节点在右子节点之上，这正是后序遍历的逆序。
    • 依次从 s2 栈中弹出节点并输出其值，即可得到后序遍历的结果。
//非递归后序遍历二叉树
template <typename T>
void BinaryTree<T>::postOrder_noRecu()
{
	_postOrder_noRecu(root);
}

template <typename T>
void _postOrder_noRecu(BinaryTreeNode<T>* tRoot)
{
	if (tRoot == NULL) return;

	stack<BinaryTreeNode<T>*> s1, s2;
	s1.push(tRoot);

	while (!s1.empty()) {
		BinaryTreeNode<T>* node = s1.top();
		s1.pop();
		s2.push(node);

		if (node->leftChild) {
			s1.push(node->leftChild);
		}
		if (node->rightChild) {
			s1.push(node->rightChild);
		}
	}

	while (!s2.empty()) {
		BinaryTreeNode<T>* node = s2.top();
		s2.pop();
		std::cout << (char)node->data << " ";
	}
}

增加下列测试代码。  

cout << "非递归方式后序遍历序列为：";
mytree2.postOrder_noRecu();
cout << endl;

新增代码的执行结果如下。  

 2.7 通过遍历序列创建二叉树

前面我们说过一个结论：

  • 1. 根据前序和中序遍历创建二叉树

//如何根据前序、中序遍历序列来创建一棵二叉树呢？	
//pre：前序遍历序列，比如是“ABDCE”，mid：中序遍历序列，比如是“DBACE”
template <typename T>
void BinaryTree<T>::CreateBTreeAccordPI(char* pre, char* mid)
{
	_CreateBTreeAccordPI(root, pre, mid, strlen(pre));
}

template <typename T>
void _CreateBTreeAccordPI(BinaryTreeNode<T>*& tnode, char* pre, char* mid, int n)//参数1为引用类型，确保递归调用中对参数的改变会影响到调用者,n:节点个数
{
	if (n == 0)
	{
		tnode = nullptr;
	}
	else
	{
		//(1)在中序遍历序列中找根，前序遍历序列中根在最前面
		int index = 0;   //下标
		while (pre[0] != mid[index])
			++index;

		tnode = new BinaryTreeNode<T>; //创建根节点
		tnode->data = mid[index];  //第一次index=2

		//(2)创建左孩子
		_CreateBTreeAccordPI(
			tnode->leftChild,   //创建左孩子
			pre + 1,           //找到前序遍历序列中左树开始节点的位置，这里跳过第一个（根）节点A，得到的是“BDCE”
			mid,               //不需要改动，仍旧是“DBACE”
			index            //左孩子有2个节点 
		);

		//(3)创建右孩子
		_CreateBTreeAccordPI(
			tnode->rightChild,   //创建右孩子
			pre + index + 1, //找到前序遍历系列中右树开始节点的位置，不难发现，前序遍历序列和中序遍历序列右树开始节点的位置相同，得到的是“CE”
			mid + index + 1, //找到中序遍历系列中右树开始节点的位置。得到的是“CE”
			n - index - 1   //右孩子节点数
		);
	}
}
  • 首先，前序序列的第一个字符 pre[0] 为根，然后在中序序列中查找根所在的位置，用index记录查找长度，找到后以根为中心，划分出左右子树。
  • 左子树：前序序列中的首地址为 pre+1, 中序序列的首地址为 mid，长度为 index。
  • 右子树：前序序列中的首地址为 pre+index+1, 中序序列的首地址为 mid+index+1，长度为 len-index-1。右子树的长度为总长度减去左子树的长度，再减去根。确定参数后，再递归求解左右子树即可。

第一次树根及左右子树划分如下图所示：

  • 2. 根据中序和后序遍历创建二叉树 

//如何根据中序、后序遍历序列来创建一棵二叉树呢？	
//mid：中序遍历序列，比如是“DBACE”，post：后序遍历序列，比如是“DBECA”
template <typename T>
void BinaryTree<T>::CreateBTreeAccordIPO(char* mid, char* post)
{
	_CreateBTreeAccordIPO(root, mid, post, strlen(mid));
}

template <typename T>
void _CreateBTreeAccordIPO(BinaryTreeNode<T>*& tnode, char* mid, char* post, int n)//参数1为引用类型，确保递归调用中对参数的改变会影响到调用者,n:节点个数
{
	//可以通过后序遍历找到根节点
	if (n == 0)
	{
		tnode = nullptr;
	}
	else
	{
		//(1)在中序遍历序列中找根，后序遍历序列中根在最后面
		int index = 0;   //下标
		while (post[n - 1] != mid[index])
			++index;

		tnode = new BinaryTreeNode<T>; //创建根节点
		tnode->data = mid[index];  //第一次index=2

		//(2)创建左孩子
		_CreateBTreeAccordIPO(
			tnode->leftChild,    //创建左孩子
			mid, //不需要改动，仍旧是“DBACE”，因为开头的都是左孩子
			post, //不需要改动，仍旧是“DBECA”，因为开头的都是左孩子
			index             //左孩子节点数
		);

		//(3)创建右孩子
		_CreateBTreeAccordIPO(
			tnode->rightChild,    //创建右孩子
			mid + index + 1, //找到中序遍历系列中右树开始节点的位置。得到的是“CE”
			post + index,   //找到后序遍历系列中右树开始节点的位置。得到的是“ECA”
			n - index - 1      //右孩子节点数
		);
	}
}

测试用例main.cpp:

#include "BinaryTree_Link.cpp"

int main()
{
	BinaryTree<int> mytree;//创建一棵二叉树
	BinaryTreeNode<int>* rootpoint = mytree.CreateNode(nullptr, E_Root, 'A'); //创建树根节点A
	BinaryTreeNode<int>* subpoint = mytree.CreateNode(rootpoint, E_ChildLeft, 'B'); //创建树根的左子节点B
	subpoint = mytree.CreateNode(subpoint, E_ChildLeft, 'D'); //创建左子节点B下的左子节点D

	subpoint = mytree.CreateNode(rootpoint, E_ChildRight, 'C'); //创建树根的右子节点C
	subpoint = mytree.CreateNode(subpoint, E_ChildRight, 'E');  //创建右子节点C下的右子节点E

	BinaryTree<int> mytree2;
	//mytree2.CreateBTreeAccordPT((char*)"ABD###C#E##");   //根据扩展二叉树前序
	//mytree2.CreateBTreeAccordPI((char*)"ABDCE", (char*)"DBACE"); //根据前序+中序
	mytree2.CreateBTreeAccordIPO((char*)"DBACE", (char*)"DBECA");  //根据中序+后序

	//-----------------
	cout << "前序遍历序列为：";
	mytree2.preOrder();   //前序遍历
	cout << endl; //换行

	cout << "中序遍历序列为：";
	mytree2.inOrder();    //中序遍历
	cout << endl; //换行

	cout << "后序遍历序列为：";
	mytree2.postOrder();  //后序遍历

	//----------------
	cout << endl; //换行
	cout << "层序遍历序列为：";
	mytree2.levelOrder();

	//---------------
	cout << endl;
	cout << "二叉树节点个数为：" << mytree2.getSize() << endl;

	//---------------
	cout << "二叉树的高度为：" << mytree2.getHeight() << endl;

	//---------------
	//查找某个节点
	int val = 'B';
	BinaryTreeNode<int>* p = mytree2.SearchElem(val);
	if (p != nullptr)
		cout << "找到了值为" << (char)val << "的节点" << endl;
	else
		cout << "没找到值为" << (char)val << "的节点" << endl;

	//---------------
	//查找某个节点的父节点
	BinaryTreeNode<int>* parp = mytree2.GetParent(p);
	if (parp != nullptr)
		cout << "找到了值为" << (char)val << "的节点的父节点" << (char)parp->data << endl;
	else
		cout << "没找到值为" << (char)val << "的节点的父节点" << endl;

	//--------------
	//测试树的拷贝
	BinaryTree<int> mytree3;
	mytree2.CopyTree(&mytree3);

	//--------------
	cout << "非递归方式前序遍历序列为：";
	mytree2.preOrder_noRecu();
	cout << endl;
	//---------------
	cout << "非递归方式中序遍历序列为：";
	mytree2.inOrder_noRecu();
	cout << endl;
	//---------------
	cout << "非递归方式后序遍历序列为：";
	mytree2.postOrder_noRecu();
	cout << endl;
	//---------------

	return 0;
}

5. 小结

这节课，我们学习了二叉树的两种存储方式——顺序存储方式、链式存储方式，以及他们的实现方式。

二叉树的顺序存储，是用一段连续的内存依次从上到下从左到右存储二叉树各个节点元素，但是很容易造成存储空间的浪费，因此顺序存储往往比较适合存储完全二叉树。

二叉树的链式存储，需要存储额外的左右节点指针。虽然增加了存储的灵活性，但也消耗了更多的存储空间。链式存储方式中，还涉及到了二叉链表和三叉链表的概念。二叉链表的一个节点结构带有两根指针以指向左右孩子节点，而三叉链表中一个节点结构带有三根指针，其中第三个指针用于指向当前节点的父节点，这给找当前节点的父节点带来了最大的便利。

由于与顺序存储相比，二叉树链式存储更加常用，所以这节课我将重点放在了二叉树链式存储的常用操作。给出了创建树节点，获取二叉树的前序、中序、后序、层序遍历序列，获取二叉树节点个数，获取二叉树高度，查找某个节点，查找某个节点的父节点，树的拷贝等操作代码。这里要重点记忆二叉树前序、中序、后序遍历代码，理解性记忆层序遍历代码，以防在面试中出现。

此外，我们也利用非递归的编程方式实现了二叉树的前序、中序、后序遍历。注意， 非递归的遍历操作需要借助栈来实现。这些代码需要我们简单理解、适当记忆，万一面试中出现，能说上几句就是好的。

最后，如何从无到有创建出一棵二叉树来呢？我们在最后用前序、中序遍历序列创建了一棵二叉树，这些代码都不复杂，但一定可以作为参考和借鉴，帮助你进一步拓展创建二叉树的思路。

 需要源代码的可以点击我的gittee：数据结构与算法C++版

醉竺
关注
  • 16
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
关于二叉树的性质以及存储方式（学习笔记）
Nanrdml的博客
03-31 744
二叉树的性质 关于二叉树，种类自然多种多样，不过不同种的二叉树会有不同的性质。 性质一：在二叉树第i层上至多有2的（i-1）次方个节点 性质二：深度为k的二叉树至多有2的k次方-1个结点（k>=1） 性质三：具有n个结点的完全二叉树的深度为【log2 n】+1 性质四：对于具有n个节点的完全二叉树，如果按照对满二叉树节点连续编号的方法，对所有节点从1开始顺序编号，则对于任意序号为i的结点有以...
【数据结构】二叉树的顺序结构及链式结构
最新发布
2301_80302655的博客
02-08 1763
设二叉树的根节点所在 层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层 上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。对于深度为K 的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。也就是 说，如果一个二叉树的层数为K，且结点总数是2的k次方-1 ，则它就是满二叉树。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
二叉树的存储方式【顺序储存（数组）、链式存储、邻接表存储等】
热门推荐
马小超
09-18 2万+
1.顺序存储结构 二叉树的顺序存储，就是用一组连续的存储单元存放二叉树中的结点。因此，必须把二叉树的所有结点安排成为一个恰当的序列，结点在这个序列中的相互位置能反映出结点之间的逻辑关系，用编号的方法从树根起，自上层至下层，每层自左至右地给所有结点编号,缺点是有可能对存储空间造成极大的浪费，在最坏的情况下，一个深度为k且只有k个结点的右单支树需要2k-1个结点存储空间。 依据二叉树的性质，完全二叉树和满二叉树采用顺序存储比较合适，树中结点的序号可以唯一地反映出结点之间的逻辑关系，这样既能够最大可能地节省存
二叉树的存储结构
qq_57484399的博客
11-15 3908
我们后来又遇到 B， B后边有“（” ， 我们就把 B 压入栈顶 ， 然后我们接下来处理的元素 ，就是 栈顶 B 的孩子 ， 直到遇到 “）” 我们才能断定此层嵌套结束， 弹出栈顶的一个根节点。• 此时，我们有发现一个问题 ， 我们根据图示知道 ， 遍历到 “（” ， 刚才遇到了 B ，所以接下来处理的是 B 的子树， 但是计算机怎么知道，我们是需要处理元素是 后遇到的 B呢？接下来 ，如果出现元素，就是B 的左孩子，如果出现逗号，那接下来 ，再出现元素就是B的右孩子 ，欲知后事如何，请接着遍历。
LeetCode第 889 题：根据前序和后序遍历构造二叉树 (C++)
zj
10-11 493
889. 根据前序和后序遍历构造二叉树 - 力扣（LeetCode） 系列题： LeetCode第 105 题：从前序与中序遍历序列构造二叉树 (C++)_zj-CSDN博客 LeetCode第 106 题：从中序与后序遍历序列构造二叉树 (C++)_zj-CSDN博客 但是这一题有一点不一样，因为根据前序遍历和后续遍历并不能唯一确定一棵树： 以上两种情况就区分不开：当一结点只有一个孩子时，无论他是左孩子还是右孩子，他们的前序遍历与后序遍历结果都是一样。 不过本题仅仅要求随意返回一颗就可以了。 前序遍历
数据结构与算法学习笔记 之 程杰《大话数据结构》数据结构篇
MuscleMonk的博客
07-26 1070
数据结构与算法学习笔记 之 程杰《大话数据结构》 第一章 数据结构绪论 数据项：数据不可分割的最小单位。在数据结构课程中，把数据项定义为最小单位，有助于我们更好地解决问题。但是真正讨论问题时，数据元素才是数据结构中建立数据模型的着眼点。 数据对象：是性质相同的数据元素的集合，是数据的子集。其中，性质相同是指数据元素具有相同数量和类型的数据项。 结构：各个组成部分相互搭配和排列的方式。 数据结构：相互之间存在一种或多种特定关系的数据元素的集合。 数据类型：是指一组性质相同的值的集合及定义在此集合上的一些操作
数据结构与算法。
HENGRYssjzj的博客
08-23 208
数据结构分为线性结构和非线性结构 线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储方式，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。 线性结构常见的有：数组，队列，链表和栈 非线性结构 非线性结构包括：二维数组，多维数组，广义表，树结构，图结构。 稀疏数组（五子棋问题中，有存盘和续上盘功能.
数据结构与算法
weixin_41560737的博客
08-25 263
数据结构与算法-Day01 算法概述 算法-前序 【1】Everybody!全场动作必须跟我整齐划一，来，我们一起来做一道题 若n1+n2+n3=1000,且n1^2+n2^2=n3^2(n1,n2,n3为自然数),求出所有n1、n2、n3可能的组合 【2】解题思路 n1 = 0 n2 = 0 n3 = 0 判断n1+n2+n3是否等于1000,之后变n3=1,n3=2,n3=3,... 然后再变n2 【3】代码实现 import time
chapter5. Java数据结构与java算法
weixin_56137667的博客
08-04 720
一、数据结构和算法概述 数据结构包括：线性结构和非线性结构。 1线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 一对一e.g. a[0] = 3; 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息（链表可以充分利用碎片内存） 线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解.
二叉链表
12-07
#include"bitree.h" #include <iostream> using namespace std; void Print(TElemType e){cout<<e;} int main() { cout<<"唐运忠 201105002229"<<endl; cout<<"--------------------------"<<endl; BiTree T; initBiTree(T); createBiTree(T); cout<<"递归前序遍历为："<<endl; preOrderTraverse(T,Print); cout<<endl; cout<<"非递归前序遍历为："<<endl; preOrderTraverse1(T,Print); cout<<endl; cout<<"递归中序遍历为："<<endl; inOrderTraverse(T,Print); cout<<endl; cout<<"递归后序遍历为："<<endl; postOrderTraverse(T,Print); return 0; }
二叉树之二叉链表
12-22
本文利用java语言模拟二叉树的二叉链表的实现，下面先对二叉树的相关概念作简单介绍： 　　二叉树：每个结点至多有两颗子树，且子树有左右之分，其次序不能任意颠倒； 基本形态：空、仅有根结点、左子树为空、右子树为空、左右子树均非空； 　　完全二叉树父子结点序号关系： 　　* 如果i=1，则结点i为根结点，否则其双亲结点为[i/2]; 　　* 如果2i > n，则结点i无左孩子，否则其左孩子结点为2i; 　　* 如果2i+1 > n，则结点i无右孩子，否则右孩子结点为2i+1; 　　二叉链表：结点包含数据域和左右指针（引用）域的链表； 　　下面主要给出二叉链表的实现： 　　1. 二叉
数据结构:二叉树存储结构及实现
m0_57781912的博客
09-12 1824
二叉树顺序结构存储以及堆的创建
二叉链表存储二叉树
weixin_34032792的博客
08-20 4564
链式存储结构 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。其结点结构为： 其中，data域存放某结点的数据信息；lchild与rchild分别存放指向左孩子和右孩子的指针，当左孩子或右孩子不存在时，相应指针域值为空（用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

醉竺

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值