数据结构——二叉树

葵花日记2025-05-14 11:50

树

树的概念与结构

***树是一种非线性的数据结构，它是由n个有限结点组成一个具有层次关系的集合。***把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

  • 有一个特殊的结点，称为根结点，根节点没有前驱结点。
  • *除了根结点外，其余结点被分成N个互不相交的集合T1，T2，......Tn,其中每一个集合Ti又是一棵结构与树类似的子树。**每棵子树的根结点有且只有一个前驱，可以有0个或者多个后继。*因此，树是递归定义的。

树形结构中，子树之间不能有交集 ，否则就不是树形结构。

非树形结构

  • 子树是不相交的（如果相交了就是图了）
  • 除了结节点外，每个结点有且仅有一个父结点。
  • 一棵结点为N的树有N-1条边。

树相关术语

树的表示

树结构相对线性表就比较复杂了，要储存表示起来就比较麻烦了，既要保存值域，也要保存结点和结点之间的关系，实际中树有很多表示方式如：双亲表示法，孩子表示法，孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

兄弟孩子表示法
cpp 复制代码 
struct TreeNode
{
	struct TreeNode* child;
	struct TreeNode* brother;
	int data;
};

二叉树

概念与结构

在树形结构中，我们最常用的就是二叉树，一棵二叉树是一个结点的有限集合，该集合由一个根结点 加上两棵别称为左子树和右子树的二叉树组成或者为空。

从上图可以看出二叉树具备以下特点：

  1. 二叉树不存在度大于2的结点。
  2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。

对于任意的二叉树都是由以下几种情况复合而成的：

特殊的二叉树

满二叉树

一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k-1,它就是满二叉树。

完全二叉树

完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树，要注意的是满二叉树是一种特殊的完全二叉树。

完全二叉树除了最后一层，每层结点都是最大，最后一层结点个数不一定达到最大。

满二叉树的性质

  • 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多为2^(i-1)个结点。
  • 若规定根结点的层数为1，则深度为h的二叉树的最大结点个数是2^h-1。
  • 若规定根结点的层数为1，具有n个结点的满二叉树的深度h=log2(n+1)。

二叉树储存结构

二叉树一般可以使用两种结构存储，一种是顺序结构，另一种是链式结构。

顺序结构

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费，完全二叉树更适合使用顺序结构存储。

现实中我们通常把堆（一种二叉树）使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

链式结构

二叉树的链式结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的储存地址。链式结构又分为二叉链和三叉链，我们学习中一般都是二叉链。

使用顺序结构实现二叉树

一般堆使用顺序结构的数组来储存数据，堆是一种特殊的二叉树，具有二叉树的特性的同时，还具有其他的特性。

堆分为大（根）堆和小（根)堆,大堆是根结点最大的堆，根结点最小的是小堆。

堆具有以下性质

  • 堆中某个结点的值总是不大于或不小于其父结点的值
  • 堆总是一棵完全二叉树。

二叉树性质

  • 对于有n个结点的完全二叉树，如果按照从上至下从左到右的数组顺序对所有结点从0开始编号，则对于序号为i的结点有：
  1. 若i>0,i位置结点的双亲序号：（i-1）/2，i=0，i为根结点编号，无双亲结点 。
  2. 若2i+1<n,左孩子序号：2i+1。若2i+2<n,右孩子序号：2i+2。否则无左孩子或者右孩子。

堆的结构

cpp 复制代码 
//堆的实现
typedef int HpDatatype;
typedef struct Heap
{
	HpDatatype* arr;
	int size;
	int capacity;
}Heap;

初始化

cpp 复制代码 
//初始化
void Init(Heap* php)
{
	assert(php);
	php->arr = NULL;
	php->size = php->capacity = 0;
}

入数据

cpp 复制代码 
void swap(HpDatatype* x, HpDatatype* y)
{
	HpDatatype tmp = *x;
	*x = *y;
	*y = tmp;
}
void AdjustUp(HpDatatype* arr, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		//若是小堆，则<
		if (arr[child] > arr[parent])
		{
			//需要交换
			swap(arr + child, arr + parent);
		}
		child = parent;
		parent = (child - 1) / 2;
	}
}
//入堆
void HPush(Heap* php, HpDatatype x)
{
	//判断空间是否足够
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HpDatatype* tmp = (HpDatatype*)realloc(php->arr, newcapacity * sizeof(HpDatatype));
		if (tmp == NULL)
		{
			perror("realloc failed!!");
			exit(1);
		}
		php->arr = tmp;
		php->capacity = newcapacity;
	}
	//正式入
	//这里以大堆为例，向上调整
	php->arr[php->size] = x;
	AdjustUp(php->arr, php->size);
	php->size++;
}

向上调整

出数据

出的是堆顶数据

步骤：

  1. 堆顶和最后一个数据交换，size--
  2. 调整，找最大的孩子，再拿父结点和孩子比较。
cpp 复制代码 
//以大堆为例
void AdjustDown(HpDatatype* arr, int parent,int n)
{
	int child = parent * 2 + 1;
	while (child <n)
	{
			int max_child = arr[child];
			if(child+1<n)
				max_child = arr[child] > arr[child + 1] ? child : child + 1;
			if (arr[parent] < arr[max_child])
			{
				swap(&arr[parent], &arr[max_child]);
				parent = max_child;
				child = parent * 2 + 1;
			}
			else
				break;
	}
}
//出堆
void HeapPop(Heap* php)
{
	//判断堆是否为空
	assert(!HeapEmpty(php) && php && php->arr);
	swap(&php->arr[0], &php->arr[php->size-1]);
	php->size--;
	//向下调整
	AdjustDown(php->arr, 0 , php->size);
}

向下调整

一些其他的

cpp 复制代码 
//取堆顶数据
HpDatatype HeapTop(Heap* php)
{
	return php->arr[0];
}
//取堆数据的数量
int HeapSize(Heap* php)
{
	return php->size;
}
//判空
int HeapEmpty(Heap* php)
{
	return php->size == 0;
}
//销毁
void HeapDestory(Heap* php)
{
	assert(php);
	free(php->arr);
	php->arr = NULL;
	php->size = php->capacity = 0;
}

堆排序

  • 调整数组使其变成一个堆结构
  • 建堆------向下调整
  • 排序
cpp 复制代码 
void HeapSort(int* a, int n)
{
	//将给定的数组调整为堆结构，我们这里以大堆为例，建堆，向下调整
	for (int i = (n - 2) / 2; i >= 0; i--)
	{
		AdjustDown(a, i, n);
		
	}
	//排序
	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, 0, end);
		end--;
	}
}

向上调整

cpp 复制代码 
void HeapSortUp(int* a, int n)
{
	//将给定的数组调整为堆结构，我们这里以大堆为例，建堆，向上调整
	for (int i =0 ; i <n; i++)
	{
		AdjustUp(a, i);

	}
	//排序
	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, 0, end);
		end--;
	}
}

使用链式结构实现二叉树

用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的储存地址，其结构如下：

cpp 复制代码 
typedef char BTDatatype;
typedef struct BinaryTreeNode
{
	BTDatatype data;//当前结点的值
	struct BinaryTreeNode* left;//指向左孩子
	struct BinaryTreeNode* right;//指向右孩子

}BTNode;

创建二叉树的方式比较复杂，为了更好地步入到二叉树的内容中，我们先手动创造出一棵链式二叉树。

cpp 复制代码 
BTNode* BuyBTNode(BTDatatype val)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		exit(1);
	}
	newnode->data = val;
	newnode->left = newnode->right = NULL;
	return newnode;
}
BTNode* CreateTree()
{
	BTNode* n1 = BuyBTNode('A');
	BTNode* n2 = BuyBTNode('B');
	BTNode* n3 = BuyBTNode('C');
	BTNode* n4 = BuyBTNode('D');
	BTNode* n5 = BuyBTNode('E');
	BTNode* n6 = BuyBTNode('F');
	n1->left = n2;
	n1->right = n3;
	n2->left = n4;
	n3->left = n5;
	n3->right = n6;
	return n1;
}

前中后序遍历

二叉树的操作离不开树的遍历，我们先来看看二叉树的遍历有哪些方式？

  • 前序遍历（先根遍历）：访问根结点的操作发生在其遍历左右子树之前。

访问顺序为：根结点，左子树，右子树

顺序：A B D NULL NULL NULL C E NULL NULL F NULL NULL

  • 中序遍历：左子树，根结点，右子树

顺序：NULL D NULL B NULL A NULL E NULL C NULL F NULL

  • 后序遍历：左子树，右子树，根结点

你们可以自己顺着逻辑写写哦，顺序是:NULL NULL D NULL B NULL NULL E NULL NULL F C A

接下来，让我们来实现它吧~

实现前中后序遍历

前序遍历：

cpp 复制代码 
//前序遍历
void preorder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%c ", root->data);
	preorder(root->left);
	preorder(root->right);
}

可能有的同学现在还一头雾水，让我们画个图，详细的为大家解释一下吧~

同理，中序遍历我们也可以写出来了

中序遍历：

cpp 复制代码 
//中序遍历
void inorder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	inorder(root->left);
	printf("%c ", root->data);
	inorder(root->right);
}

后序遍历：

cpp 复制代码 
//后序遍历
void postorder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	postorder(root->left);
	postorder(root->right);
	printf("%c ", root->data);
}

打印结果：

结点个数及其高度

求二叉树结点的个数
  • 要求二叉树结点的个数，我们只要遍历一遍就可以了，思路是不是很简单啊，接下来让我们动手写代码吧！
cpp 复制代码 
//求二叉树结点的个数
int BinaryTreeSize(BTNode* root, int size)
{
	if (root == NULL)
	{
		return 0;
	}
	size++;//不为空，结点个数++
	BinaryTreeSize(root->left, size);
	BinaryTreeSize(root->right,size);
    return size;
}

有没有人发现了坑？这个代码打印出来为0，是的，因为我们写的传值调用，而不是传址。是不能改变size滴！

正确写法应该是 ：

cpp 复制代码 
//求二叉树结点的个数
int BinaryTreeSize(BTNode* root, int* size)
{
	if (root == NULL)
	{
		return 0;
	}
	(*size)++;
	BinaryTreeSize(root->left, size);
	BinaryTreeSize(root->right,size);
	return *size;
}
  • 让我们再思考一种方法，
cpp 复制代码 
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}

这样是不是更简便呢？

求二叉树叶子结点的个数

叶子结点即度为0的结点，叶子结点的个数=左子树叶子结点的个数+右子树叶子结点的个数

cpp 复制代码 
//二叉树叶子结点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return BinaryTreeLeafSize(root->left)+ BinaryTreeLeafSize(root->right);
}
二叉树第k层结点个数
cpp 复制代码 
//二叉树第k层结点的个数
int BinaryTreeLevelKSize(BTNode* root, int k)//k指二叉树的层数
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return BinaryTreeLevelKSize(root->left, k-1) + BinaryTreeLevelKSize(root->right, k-1);
}
二叉树的深度高度
cpp 复制代码 
//二叉树的深度高度
int BinaryTreeDepth(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	int max = BinaryTreeDepth(root->left) > BinaryTreeDepth(root->right) ? BinaryTreeDepth(root->left) : BinaryTreeDepth(root->right);
	return 1 + max;
}
查找值为X的结点

依旧遍历，当找到值为X的点时，返回

cpp 复制代码 
//查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDatatype x)
{
	//先判断root是否为空，空，返回NULL
	if (root == NULL)
	{
		return NULL;
	}
	//判断结点里是否有x，有，返回结点
	if (root->data == x)
		return root;
	//遍历左子树
	if (BinaryTreeFind(root->left, x) != NULL)
		return BinaryTreeFind(root->left, x);
	//遍历右子树
	if (BinaryTreeFind(root->right, x) != NULL)
		return BinaryTreeFind(root->right, x);
	//都没有，返回NULL
	return NULL;
}
销毁二叉树

使用二级指针否则无法改变最终地址root

cpp 复制代码 
void BinaryTreeDestory(BTNode** root)
{
	if (*root == NULL)
	{
		return;
	}
	BinaryTreeDestory(&((*root)->left));
	BinaryTreeDestory(&((*root)->left));
	free(*root);
	*root = NULL;
}
相关推荐
真的想上岸啊7 分钟前
c语言第一个小游戏：贪吃蛇小游戏06
c语言·算法·链表
hardStudy_h13 分钟前
C程序的存储空间分配
c语言·开发语言
chenyuhao20241 小时前
链表的面试题4之合并有序链表
数据结构·链表·面试·c#
h汉堡1 小时前
C/C++内存管理
java·c语言·开发语言·c++·学习
水水沝淼㵘2 小时前
嵌入式开发学习日志（数据结构--顺序结构单链表）Day19
linux·服务器·c语言·数据结构·学习·算法·排序算法
yutian06062 小时前
C语言中的宏
c语言·开发语言
莹莹学编程—成长记3 小时前
list基础用法
数据结构·list
清幽竹客3 小时前
redis数据结构-09 （ZADD、ZRANGE、ZRANK）
数据结构·数据库·redis
JANYI20183 小时前
C语言易混淆知识点详解
java·c语言·算法
热门推荐
01YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03KGG转MP3工具|非KGM文件|解密音频04DeepSeek各版本说明与优缺点分析05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06Coze扣子平台完整体验和实践（附国内和国际版对比）07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09苍穹外卖面试总结10YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU