二叉树的链式存储

最新推荐文章于 2023-09-18 12:56:47 发布
最新推荐文章于 2023-09-18 12:56:47 发布
阅读量246 收藏 1
点赞数
分类专栏： DS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PNUHC/article/details/90729351
版权

1. 分析顺序存储二叉树的优缺点

2. 使用孩子表示法实现二叉树的以下操作：

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


// 二叉树的创建 
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* root, BTDataType x); 

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

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

 1.分析顺序存储二叉树的优缺点

顺序存储是用一段连续的存储单元（数组）存储线性表的数据元素
优点： 存储密度大，存储空间利用率高
缺点： 插入或删除元素是不方便
仅仅比较适合完全二叉树，否则会造成资源浪费

2.使用孩子表示法实现二叉树的以下操作：

代码如下：
这里要利用队列的代码：（详细见前面队列博客）
栈和队列
这里只上传二叉树的代码，队列的详见链接

BinTree.h

#pragma once
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<string.h>
#include<stdlib.h>

//孩子表示法
typedef char BTDataType;
typedef struct BTNode
{
	struct BTNode* _pLeft;
	struct BTNode* _pRight;
	BTDataType _data;
}BTNode;

// 二叉树的创建 
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* root, BTDataType x);

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

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


//队列（队列中每个元素是树的节点BTNode*）
//这里队列的实现详见上面链接
typedef BTNode* QDataType;
typedef struct QNode
{
	struct QNode* _pNext;
	QDataType _data;
}QNode,*pQNode;
typedef struct Queue
{
	QNode* _front;
	QNode* _back;
}Queue;

void QueueInit(Queue* q);
void QueuePush(Queue* q, QDataType data);
void QueuePop(Queue* q);
QDataType QueueFront(Queue* q);
QDataType QueueBack(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
void QueueDestroy(Queue* q);
//void TestQueue();

BinTree.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "BinTree.h"

BTNode* BuyBinNode(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)
{
	/*if (array = NULL)
		return NULL;*/
	BTNode* pRoot = NULL;
	if ((*index) < size && array[*index] != invalid)
	{
		// 根节点
		pRoot = BuyBinNode(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;//要是函数参数少一个的话，封装一次就OK
	return _CreateBinTree(array, size, &index, invalid);
}

// 二叉树的拷贝 
BTNode* CopyBinTree(BTNode* pRoot)
{
	BTNode* pNewroot = NULL;
	if (pRoot)
	{
		pNewroot = BuyBinNode(pRoot->_data);
		pNewroot->_pLeft = CopyBinTree(pRoot->_pLeft);
		pNewroot->_pRight = CopyBinTree(pRoot->_pRight);
	}
	return pNewroot;
}

// 二叉树的销毁 
void DestroyBinTree(BTNode** pRoot)//为什么要传二级指针
{
	//assert(pRoot);
	if (*pRoot)
	{
		DestroyBinTree(&(*pRoot)->_pLeft);
		DestroyBinTree(&(*pRoot)->_pRight);
		free(*pRoot);
		*pRoot = NULL;
	}
}

// 递归：前序遍历 
void PreOrder(BTNode* pRoot)
{
	//assert(pRoot);
	if (pRoot)//结束条件不能忘
	{
		printf("%c ", pRoot->_data);
		PreOrder(pRoot->_pLeft);
		PreOrder(pRoot->_pRight);
	}
}

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

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

// 层序遍历 
void LevelOrder(BTNode* pRoot)
{
	Queue q;
	if (NULL == pRoot)
		return;
	QueueInit(&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");
}

// 获取二叉树中节点个数 
int GetBinTreeSize(BTNode* pRoot)//
{
	//assert(pRoot);
	if (NULL == pRoot)
		return 0;
	//if (pRoot)
		//return 1;
	return 1 + GetBinTreeSize(pRoot->_pLeft) + GetBinTreeSize(pRoot->_pRight);
}

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

// 获取二叉树中叶子节点个数 
int GetLeafCount(BTNode* pRoot)
{
	if (NULL == pRoot)
		return 0;
	if (pRoot->_pLeft == NULL && pRoot->_pRight == NULL)
		return 1;
	return GetLeafCount(pRoot->_pLeft) + GetLeafCount(pRoot->_pRight);
}

// 获取二叉树深度(高度) 
int GetBinTreeHeight(BTNode* pRoot)
{
	BTNode* pTmp = pRoot;
	int deep = 0;
	if (pTmp)
	{
		int leftdeep = GetBinTreeHeight(pTmp->_pLeft);
		int rightdeep = GetBinTreeHeight(pTmp->_pRight);
		deep = leftdeep >= rightdeep ? leftdeep + 1 : rightdeep + 1;
	}
	return deep;
}

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

void Swap(BTNode** pleft, BTNode** pright)
{
	BTNode* pTmp = *pleft;
	*pleft = *pright;
	*pright = pTmp;
}

// 二叉树的镜像 
void Mirror(BTNode* pRoot)
{
	if (pRoot)
	{
		Swap(&pRoot->_pLeft, &pRoot->_pRight);
		Mirror(pRoot->_pLeft);
		Mirror(pRoot->_pRight);
	}
}

void MirrorNor(BTNode* pRoot)
{
	Queue q;
	if (NULL == pRoot)
		return;
	QueueInit(&q);
	QueuePush(&q, pRoot);
	while (!QueueEmpty(&q))
	{
		BTNode* pCur = QueueFront(&q);
		Swap(&pCur->_pLeft, &pCur->_pRight);
		if (pCur->_pLeft)
			QueuePush(&q, pCur->_pLeft);
		if (pCur->_pRight)
			QueuePush(&q, pCur->_pRight); 
		QueuePop(&q);
	}
	QueueDestroy(&q);
}

// 判断二叉树是否是完全二叉树 
int BinaryTreeComplete(BTNode* root)
{
	if (NULL == root)
		return 1;
	int left = GetBinTreeHeight(root->_pLeft);
	int right = GetBinTreeHeight(root->_pRight);
	int diff = left - right;
	if (diff < -1 || diff > 1)
		return 0;
	return BinaryTreeComplete(root->_pLeft) && BinaryTreeComplete(root->_pRight);
}

void TestBinTree()
{
	char* str = "ABD$$$CE$$F";
	BTNode* pRoot = CreateBinTree(str, strlen(str), '$');
	Mirror(pRoot);
	MirrorNor(pRoot);
	printf("前序遍历结果：");
	PreOrder(pRoot);
	printf("\n");

	printf("中序遍历结果：");
	InOrder(pRoot);
	printf("\n");

	printf("后序遍历结果：");
	PostOrder(pRoot);
	printf("\n");

	printf("层序遍历结果：");
	LevelOrder(pRoot);
	printf("\n");
	int size = GetBinTreeSize(pRoot);
	printf("该二叉树的节点个数为：%d\n", size);

	int count = GetKLevelNodeCount(pRoot, 3);
	printf("第3层的节点个数为：%d\n", count);

	int leave = GetLeafCount(pRoot);
	printf("该二叉树中的叶子结点的个数为：%d\n", leave);

	int height = GetBinTreeHeight(pRoot);
	printf("该二叉树的深度为：%d\n", height);

	//判断是否为完全二叉树，a = 0 不是，  a = 1 是
	//int a = BinaryTreeComplete(pRoot);
	//if (a == 1)
	//	printf("是完全二叉树\n");
	//else
	//	printf("不是完全二叉树\n");

	//判断E是否在二叉树内
	if (BinaryTreeFind(pRoot, 'E'))
	{
		printf("E is in BTree!!!\n");
	}
	else
	{
		printf("E is not in BTree!!!\n");
	}
	DestroyBinTree(&pRoot);
}

int main()
{
	TestBinTree();
	system("pause");
	return 0;
}

测试二叉树结构如图：
在这里插入图片描述

测试结果：
在这里插入图片描述

PHONER'S NUHC
关注
专栏目录
链表和二叉树
lzy520o的博客
05-16 1382
链表 链表 [Linked List]：链表是由一组不必相连（不必相连：可以连续也可以不连续）的内 存结构（节点），按特定的顺序链接在一起的抽象数据类型。 链表是离散存储性结构 常用链表有3类：单链表、双向链表、循环链表 数组是一种连续存储线性结构，元素类型相同，大小相等。 链表和数组各自的优缺点： 链表 优点：空间没有限制 、插入删除元素很快 缺点：存取速度慢 数组 优点：存取速度快 缺点：必须事先知道数组的长度、插入删除元素很慢、空间有限制 单链表 由各个内存结构通过一个Next指针链接在一起组成，每一
二叉树链式存储结构
最新发布
qq_63981383的博客
09-18 1535
的（一颗二叉树由根，左子树和右子树组成，左子树又是由根，左子树，右子树组成...依次递归），因此后面有关二叉树的操作都是根据递归实现的。二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链。高阶二叉树(AVL树、红黑树)会用到三叉链。​​。
C语言实现二叉树源代码
10-02
C语言实现二叉树，可用作库 包含添加节点，删除节点，查找节点等函数 节点上存储的是网络前缀 适用于网络前缀的查找，添加等任务
二叉树——链式存储
yanllele的博客
07-16 464
二叉树链式存储 链式存储 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链， 一般使用二叉链表 package com.bit.BinaryTree; import java.util.LinkedList; ...
【数据结构】二叉树链式结构实现（C语言）
xiangjunyes的博客
06-28 2261
#include "string.h" #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间初始分配量 */ typedef int Status; /* Status是函数的类
二叉树创建C语言实现
02-24
通过链式存储结构实现二叉树的创建，包含如下操作： 1. 创建树； 2. 销毁树； 3. 清空树； 4. 插入结点； 5. 删除结点； 6. 获取结点； 7. 获取根结点； 8. 获取树的结点数； 9. 获取树的高度； 10. 获取树的度； 11. 显示二叉树。
C语言 二叉树的链式存储实例
12-31
二叉树的链式存储 实现二叉树的基本操作：建立、遍历、计算深度、结点数、叶子数等。 输入C，先序创建二叉树，#表示空节点； 输入H：计算二叉树的高度； 输入L：计算二叉树的叶子个数； 输入N：计算二叉树节点总个数...
二叉树链式存储结构 第六章实验报告.doc
07-06
在实验中，学生通过编写和调试这些函数，不仅掌握了二叉树链式存储结构的基本概念，还深化了对二叉树遍历算法的理解，并意识到亲手编写程序对学习的重要性。通过运行程序，可以观察到二叉树的构建和遍历结果，从而...
二叉树链式存储结构代码实现
qq_42430426的博客
07-23 5261
上一篇博客已经介绍过实际内容了，这一篇直接上干货代码了。 结构体 前面写的是用c语言写的，用的也是递归的方法 typedef char BTDataType; typedef struct BTNode { struct BTNode* left; struct BTNode* right; BTDataType data; }BTNode; 1、创建二叉树 typedef struct ...
数据结构(C++) - 实现二叉树链式存储结构
指尖上跳转
09-08 1381
#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()
二叉树（链式存储）
qq_43906881的博客
10-07 2092
二叉树（链式存储） 1、树数据结构与数组和链表的区别 数组存储方式的分析 优点： 通过 下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 缺点： 如果要检索具体某个值，或者插入值( 按一定顺序) 会整体移动，效率较低 链式存储方式的分析 优点： 在一定程度上对数组存储方式有优化(比如： 插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。 缺点： 在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历） 树存储方式的分析
面试题 二叉树的前序遍历，中序遍历，后序遍历（递归实现）
惊鸿一瞥
11-20 926
前序遍历递归解法： （1）如果二叉树为空，空操作 （2）如果二叉树不为空，访问根节点，前序遍历左子树，前序遍历右子树 中序遍历递归解法 （1）如果二叉树为空，空操作。 （2）如果二叉树不为空，中序遍历左子树，访问根节点，中序遍历右子树
了解二叉树的一系列，创建遍历，删除等
delete_bug的博客
05-18 331
什么是二叉树： 在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。 如图所示 关于树的术语 树的结点（node）：包含一个数据元素及若干指向子树的分支； 孩子结点（child node）：结点的子树的根称为该结点的孩子； 双亲结点：B 结点是A 结点的孩子，则A结点是B 结点的双亲； 兄弟结点：同一双亲的孩子结点；堂兄结点：同一层上结点； 祖先结点: 从根到该结点的所经分支上的所有结点
二叉树的基本操作
qq_36971449的博客
08-21 157
本次写了一些二叉树的基础操作代码如下： 头文件如下： #pragma once #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;assert.h&gt; #include &lt;stdlib.h&gt; //struct TreeNode //{ // // data; // TNDataType data; ...
二叉树
Q_feifeiyu的博客
04-21 202
二叉树：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 特点： 1、每个节点最多有两颗子树 2、二叉树是有序树，即左右子树的顺序不能颠倒 数据结构种的二叉树：（5种） 特殊的二叉树： 满二叉树、完全二叉树、平衡二叉树 存储结构： 顺序（只适用于完全二叉树---堆）、 链式两种存储方式 三种遍历方式：...
二叉树的遍历（基于栈的非递归方式实现）
qq_29762941的博客
09-14 615
原文链接:二叉树的遍历（基于栈的非递归方式实现） 二叉树的遍历（基于栈的非递归方式实现） 注意:pop的顺序就是对应遍历的打印顺序。 在写二叉树的时候如果用递归实现二叉树的遍历很简单，但是用非递归来实现二叉树的遍历就不那么简单了需要一些技巧。 那为什么还要非递归实现呢？个人理解：如果树的高度很大，超过了允许递归的次数，那么就会出错，比如我记得python只允许递归100次（不知道记错没） ...
二叉树基本操作实现（二叉树的链式存储）
weixin_30911809的博客
08-25 300
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...
二叉树基本概念——二叉树（概念、性质、顺序存储，链式存储）、满二叉树与完全二叉树、二叉链表，三叉链表，双亲链表
浅然的专栏
11-07 5580
一、二叉树定义 二叉树的特点是每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒 下面是含三个结点的二叉树（方便理解）二、二叉树性质1、在二叉树的第i层上至多有2^(i-1)个结点（i>=1）：比如第1层只有一个结点（根）2、深度为k的二叉树至多有2^(k)-1个结点（k>=1）3、对任何一个二叉树T，如果其终端结点数为n0，度为2的结点数
C语言实现二叉树链式存储及操作
"这篇资源是关于C语言中二叉树链式存储的实例教程，提供了创建、遍历、计算深度、节点数、叶子数等基本操作的代码实现。通过输入不同的字符指令，用户可以执行相应的操作，如创建二叉树、计算高度、查找特定值的节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值