数据结构【链式二叉树相关操作】

最新推荐文章于 2022-09-18 12:38:39 发布
最新推荐文章于 2022-09-18 12:38:39 发布
阅读量169 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40185097/article/details/90601522
版权

使用链式存储结构存储二叉树的相关操作:**

// 二叉树的创建 
BTNode* CreateBinTree(BTDataType* array, int size, BTDataType invalid);

// 二叉树的拷贝 
BTNode* CopyBinTree(BTNode* pRoot);

// 二叉树的销毁 
void DestroyBinTree(BTNode** pRoot);

// 递归：前序遍历 
void PreOrder(BTNode* pRoot);

// 递归：中序遍历 
void InOrder(BTNode* pRoot);

// 递归：后序遍历 
void PostOrder(BTNode* pRoot);

// 层序遍历 
void LevelOrder(BTNode* pRoot);

// 获取二叉树中节点个数 
int GetBinTreeSize(BTNode* pRoot);

// 获取二叉树中第K层节点个数 
int GetKLevelNodeCount(BTNode* pRoot, int K);

// 获取二叉树中叶子节点个数 
int GetLeafCount(BTNode* pRoot);

// 获取二叉树深度(高度) 
int GetBinTreeHeight(BTNode* pRoot);

// 检测值为x的元素是否在二叉树中，在返回该节点的地址，否则返回NULL 
BTNode* BinaryTreeFind(BTNode* pRoot, BTDataType x);

// 二叉树的镜像 
void Mirror(BTNode* pRoot);

// 判断二叉树是否是完全二叉树 
int BinaryTreeComplete(BTNode* pRoot);

二叉树链式结构结点定义（孩子表示法）：

typedef char BTDataType;
typedef struct BTNode
{
	struct BTNode* _pLeft;
	struct BTNode* _pRight;
	BTDataType _data;
}BTNode;

1.二叉树的创建

在这里对底层结构进行了一层简单的封装，为了用户更简单的理解和使用，用户只需要传入存放数据的array，元素个数size，和无效符号invalid就可以使用了

//申请新节点
BTNode* BuyBinTreeNode(BTDataType data)
{
	BTNode* pNewNode = (BTNode*)malloc(sizeof(BTNode));
	if (NULL == pNewNode)
	{
		assert(0);
		return NULL;
	}
	pNewNode->_data = data;
	pNewNode->_pLeft = NULL;
	pNewNode->_pRight = NULL;
	return pNewNode;
}

BTNode* _CreateBinTree(BTDataType* array, int size,int* index,BTDataType invalid)
{
	BTNode* pRoot = NULL;
	if (*index < size && invalid != array[*index])
	{
		//根节点
		pRoot = BuyBinTreeNode(array[*index]);
		//根的左子树
		++(*index);
		pRoot->_pLeft = _CreateBinTree(array, size, index,invalid);
		//根的右子树
		++(*index);
		pRoot->_pRight = _CreateBinTree(array, size, index,invalid);
	}
	return pRoot;
}

//二叉树的创建
BTNode* CreateBinTree(BTDataType* array, int size, BTDataType invalid)
{
	int index = 0;
	return _CreateBinTree(array, size, &index, invalid);
}

2.二叉树的拷贝

BTNode* CopyBinTree(BTNode* pRoot)
{
	BTNode* NewpRoot = NULL;
	if (NULL == pRoot)
		return 0;
	NewpRoot = BuyBinTreeNode(pRoot->_data);
	NewpRoot->_pLeft = CopyBinTree(pRoot->_pLeft);
	NewpRoot->_pRight = CopyBinTree(pRoot->_pRight);

	return NewpRoot;
}

3.二叉树的销毁

如果先删除根节点那么就找不到该节点的左右孩子了，所以必须将左右孩子先删除，才能删除根节点

//二叉树的销毁
void DestroyBinTree(BTNode** pRoot)
{
	assert(pRoot);
	if (*pRoot)
	{
		DestroyBinTree(&(*pRoot)->_pLeft);
		DestroyBinTree(&(*pRoot)->_pRight);
		free(pRoot);
	}
}

4.前序、中序、后序遍历

  1. NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
  2. LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
  3. LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
//前序遍历
void PreOrder(BTNode* pRoot)
{
	if (pRoot)
	{
		printf("%c", pRoot->_data);
		PreOrder(pRoot->_pLeft);
		PreOrder(pRoot->_pRight);
	}
}

//中序遍历
void InOrder(BTNode* pRoot)
{
	if (pRoot)
	{
		InOrder(pRoot->_pLeft);
		printf("%c", pRoot->_data);
		InOrder(pRoot->_pRight);
	}
}

//后序遍历
void PostOrder(BTNode* pRoot)
{
	if (pRoot)
	{
		PostOrder(pRoot->_pLeft);
		PostOrder(pRoot->_pRight);
		printf("%c", pRoot->_data);
	}
}

5.层序遍历

层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

在这里借助队列先入先出的特性来完成层序遍历：

  1. 定义一个队列
  2. 将头结点入队列
  3. 左孩子存在，则将左孩子入队列
  4. 右孩子存在，则将右孩子入队列
  5. 删除队头元素
// 层序遍历 
void LevelOrder(BTNode* pRoot)
{
	if (NULL == pRoot)
		return 0;

	Queue q;                 //定义一个队列
	QueueInin(&q);
	QueuePush(&q, pRoot);    //将头结点入队列
	while (!QueueEmpty(&q))
	{
		BTNode* pCur = QueueFront(&q);
		printf("%c", pCur->_data);
		if (pCur->_pLeft)
			QueuePush(&q, pCur->_pLeft);  //先将左孩子入队列
		if (pCur->_pRight)
			QueuePush(&q, pCur->_pRight); //再将右孩子入队列

		QueuePop(&q);     //删除队头元素
	}
	QueueDestroy(&q);    //销毁队列
	printf("\n");
}

6.二叉树中节点个数

二叉树中结点个数：左子树结点个数+右子树结点个数+1（根结点）

int GetBinTreeSize(BTNode* pRoot)
{
	if (NULL == pRoot)
		return 0;
	return GetBinTreeSize(pRoot->_pLeft) + GetBinTreeSize(pRoot->_pRight) + 1;

}

7.二叉树中第K层节点个数

// 获取二叉树中第K层节点个数 
int GetKLevelNodeCount(BTNode* pRoot, int K)
{
	if (NULL == pRoot || K <= 0)
		return 0;
	if (1 == K)
		return 1;
	return GetKLevelNodeCount(pRoot->_pLeft, K - 1) + GetKLevelNodeCount(pRoot->_pRight, K - 1);
}

8.二叉树中叶子节点个数

// 获取二叉树中叶子节点个数 
int GetLeafCount(BTNode* pRoot)
{
	if (NULL == pRoot)
		return 0;
    //如果只有一个结点则返回1
	if (NULL == pRoot->_pLeft && NULL == pRoot->_pRight)
		return 1;
    //
	return GetLeafCount(pRoot->_pLeft) + GetLeafCount(pRoot->_pRight);
}

9.二叉树深度(高度)

树的深度=max(左子树深度，右子树深度)+1（根节点深度）

// 获取二叉树深度(高度) 
int GetBinTreeHeight(BTNode* pRoot)
{
	if (NULL == pRoot)
		return 0;

	int maxLeft = GetBinTreeHeight(pRoot->_pLeft);  //左子树的深度
	int maxRight = GetBinTreeHeight(pRoot->_pRight);//右子树的深度
	if (maxLeft < maxRight)
		return maxRight+1;
	return maxLeft+1;    
}

10.检测值为x的元素是否在二叉树中，在返回该节点的地址，否则返回NULL

// 检测值为x的元素是否在二叉树中，在返回该节点的地址，否则返回NULL 
BTNode* BinaryTreeFind(BTNode* pRoot, BTDataType x)
{
	BTNode* pRet = NULL;
	if (NULL == pRoot)
		return NULL;

	if (pRoot->_data == x)
		return pRoot;
	
	if (pRet = BinaryTreeFind(pRoot->_pLeft, x))
		return pRet;

	return BinaryTreeFind(pRoot->_pRight, x);
}

11.二叉树的镜像

二叉树的镜像就是将从根节点开始的每一个节点的左右子节点交换位置

void Swap(BTNode* pLeft, BTNode* pRight)
{
	BTNode* pTemp = pLeft;
	pLeft = pRight;
	pRight = pTemp;
}
// 二叉树的镜像 
//递归方式
void Mirror(BTNode* pRoot)
{
	if (pRoot)
	{
		Swap(&pRoot->_pLeft, &pRoot->_pRight);
		Mirror(pRoot->_pLeft);
		Mirror(pRoot->_pRight);
	}
}
//非递归方式
void Mirror(BTNode* pRoot)
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, pRoot);
	while (!QueueEmpty(&q))
	{
		BTNode* pCur = QueueFront(&q);
		Swap(&pRoot->_pLeft, &pRoot->_pRight);

		if (pCur->_pLeft)
			QueuePush(&q, pCur->_pLeft);
		if (pCur->_pRight)
			QueuePush(&q, pCur->_pRight)

			QueuePop(&q);
	}
}

12. 判断二叉树是否是完全二叉树

// 判断二叉树是否是完全二叉树 
int BinaryTreeComplete(BTNode* pRoot) {
	if (pRoot == NULL)
		return 1;
	Queue q;
	QueueInit(&q);
	QueuePush(&q, pRoot);
	while (pRoot != NULL) {//若节点不为空，就进行出队列，并入队节点的左右孩子
		pRoot = QueueFront(&q);
		QueuePop(&q);
		if (pRoot != NULL) {
			QueuePush(&q, pRoot->_pLeft);
			QueuePush(&q, pRoot->_pRight);
		}
	}
	while (!QueueEmpty(&q)) {//节点为NULL但队列不空时
		pRoot = QueueFront(&q);
		QueuePop(&q);
		if (pRoot == NULL)//在非空节点后又出现了NULL节点，说明不是完全二叉树
			return -1;
	}
	return 1;
}

总结：二叉树的链式结构的相关操作，很多操作都是使用递归来完成的，这一切都是因为二叉树的特殊性，将一棵二叉树分为根节点、左子树和右子树三大部分，再结合具体的问题，就可以使用递归完成相关操作了

xia0fu
关注
二叉链表 二叉树 基本操作
qq_44413587的博客
06-03 894
// // main.c // 二叉树 // // Created by 511 on 2020/6/3. // Copyright © 2020 511. All rights reserved. // //**结构体定义** #include<stdio.h> #include<stdlib.h> typedef struct TreeNode{ int data; struct TreeNode* left;//左孩子 struct Tree.
数据结构-二叉树的链式存储
热门推荐
qq_45967533的博客
03-20 1万+
文章目录二叉树的链式结构链式结构的遍历二叉树链式存储的实现二叉树节点的创建前序遍历中序遍历后序遍历二叉树元素个数叶节点的个数第k层节点的个数查找元素二叉树销毁二叉树的层序遍历判断是否为完全二叉树 二叉树的链式结构 二叉树的存储结构有顺序结构和链式结构两种，顺序结构我已经在上篇进行了详细的讲解，地址：数据结构-二叉树的顺序存储与堆（堆排序），本篇我们就主要讲解二叉树的链式存储。 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右
链式结构存储二叉树的基本操作
09-01
采用链式结构存放二叉树，实现二叉数的创建，实现二叉数的遍历（前序，后序，中序层次遍历），分别求二叉树的叶子结点和结点的数目，二叉树的查找，二叉树的深度。
链式二叉树的基本操作
weixin_63946552的博客
09-18 610
二叉树的基本操作
链式二叉树的基本操作（建议收藏！！！）
2021dragon的博客
05-07 8739
文章目录二叉树的深度优先遍历前序遍历中序遍历后序遍历二叉树的广度优先遍历层序遍历结点的个数叶子结点的个数第k层结点的个数值为x的结点树的最大深度判断二叉树是否是完全二叉树判断二叉树是否是单值二叉树判断二叉树是否是对称二叉树判断二叉树是否是平衡二叉树判断二叉树是否是另一棵二叉树的子树判断两棵二叉树是否相同翻转二叉树二叉树的销毁二叉树的深度遍历（接口型题目）前序遍历中序遍历后序遍历 typedef char BTDataType;//结点中存储的元素类型（以char为例） typedef struct BTN
数据结构：二叉树（链式存储）
12-07
在IT领域，数据结构是计算机科学的基础，它们是组织和管理数据的方式，直接影响到程序的效率和性能。其中，二叉树是一种非常重要的数据...这些知识对于理解和操作二叉树至关重要，也是数据结构和算法学习中的基础部分。
数据结构-二叉树的创建与遍历（链式存储结构）
最新发布
11-13
二叉树作为数据结构中的重要概念，是用于表示有限数据集的一种方式，特别是链式存储结构。在这个主题中，我们将深入探讨如何创建二叉树以及如何遍历它们。 首先，我们来理解二叉树的基本概念。二叉树是由节点构成的...
二叉树(线索二叉树、链式二叉树、有序二叉树) 常见操作代码实现
04-08
内容概要：用c代码完成链式二叉树、有序二叉树、线索二叉树的的常见操作。其中包括构建、销毁、前序/后序/中序遍历、高度、密度、添加、删除、查询等操作 适合人群：具备一定编程基础，尤其是c语言基础，并很好地...
数据结构：二叉树相关代码
08-24
这个压缩包“数据结构：二叉树相关代码”很可能包含了各种二叉树操作的实现，如插入、删除、遍历等，以及可能的自定义二叉树类型，比如二叉搜索树、平衡二叉树（AVL树或红黑树）等。 首先，二叉树是一种非线性数据...
数据结构：二叉树的链式结构及对链式二叉树的一些基本操作
m0_56611833的博客
11-20 1096
文章目录二叉树的实现之链式结构二叉树的节点个数二叉树叶子节点的个数二叉树第K层节点的个数二叉树的深度/高度二叉树查找值为x的节点判断二叉树是否是完全二叉树二叉树销毁二叉树的遍历前序遍历、中序遍历、后序遍历、层序遍历、广度优先遍历、深度优先遍历 本文总结课上讲到的链式二叉树的一些基本操作，具体有 计算二叉树的结点的个数 计算二叉树叶子节点的个数 计算二叉树第K层结点的个数 计算二叉树的深度/高度 查找并返回值为x的结点 判断二叉树是否是完全二叉树 二叉树的销毁 二叉树的前、中、后序遍历 二叉树的层序遍历
链式二叉树——操作总结
漫鱼
05-05 805
链式二叉树——操作总结 二叉树中反复使用递归思想，掌握寻找子问题的能力就能解决所有二叉树问题。 非递归先序遍历需要用到数据结构栈，下文提供两种思路解决。层序遍历用到队列，也即广度遍历思想。 完整代码github：https://github.com/zzaiyuyu/BinTree BinTree.h #pragma once typedef char BTDataType; ty...
二叉树基本操作实现（二叉树的链式存储）
weixin_30911809的博客
08-25 280
1 #include <iostream> 2 using namespace std; 3 typedef struct bintree_node 4 { 5 int data; 6 bintree_node *lchild; 7 bintree_node *rchild; 8 }bintr...
【数据结构】链式二叉树 - 前中后层序遍历+基本操作
Bitdancing的专栏
11-15 1310
二叉树 概念 二叉树要么是空树，要么是非空树，即由根结点、根结点的左子树和根结点的右子树组成。 可以看出二叉树是递归定义的，后序操作都是基于这个结论实现的。 前序（先序）遍历 按照 根结点-左子树-右子树 的顺序遍历树。 void PreOrder(BTNode* root) { if (root == NULL) { printf("NULL "); return; } printf("%c ", root->data); PreOrder(root->left);
13、数据结构与算法 - 二叉树（三）链式存储二叉树
shengdaVolleyball的博客
05-21 329
链式存储二叉树 #include <stdio.h> #include "string.h" #include "stdlib.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 /* 存储空间初始分配量 */ #define MAXSIZE 100 /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typede.
数据结构 二叉树 链式存储结构
oowadanoko的博客
01-28 672
二叉树 链式存储结构 结构定义： template<typename ElemType> struct BiNode { ElemType data; struct BiNode* lchild, * rchild; }; template<typename ElemType> using BiTree = BiNode<ElemType>*; 基本操作： 遍历：二叉树最基本也最重要的操作，分成了前序遍历、中序遍历、后序遍历、层次遍历四种 前序遍历递归算法：首
常用数据结构之链式存储二叉树
阿罗的技术博客
03-17 1503
树：是n(n>=0)个节点的有限集合。有且仅有一个特定的根节点。每个节点的子节点的个数称为节点的度，树的度是树内各个节点度的最大值。除了根节点，每个节点都有其双亲，同一双亲的节点称为兄弟节点，子节点位于其双亲节点的下一层，其中根节点为第一层。树中节点的最大层次为树的深度或高度。树中各子树次序不可换的称为有序树，否则为无序树。      树的三种表示法：      1、双亲表示法。既每个节点中，
数据结构—二叉树链式结构的实现
weixin_42357849的博客
04-19 801
一.二叉树的链式结构。 二叉树的链式存储结构是指用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。 链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链。 二.链式结构的实现。 1.二叉树管理: 节点管理： #define BSTDataType int...
二叉树的一系类基本操作
Advsance的博客
09-07 162
二叉树的创建 根据定义二叉树有左右两个节点，本文是用孩子双亲表示法创建的二叉树： 完成树的定义，给出构造函数方便节点的创建 struct BTNode { BTNode(int data) :_pleft(nullptr) ,_pRight(nullptr) ,_data(data) {} BTNode* _pleft; BTNode* _pRight; int _data;...
链式存储结构：二叉树表示与数据结构基础
本文档主要探讨了链式存储结构在二叉树表示中的应用，特别是在C++编程语言中的实现。首先，介绍了顺序存储结构，它...本文档提供了链式存储结构在二叉树表示中的实践应用，并强调了数据结构在软件开发中的核心地位。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值