【数据结构】二叉树———Lesson2

news2024/9/23 5:24:19

Hi~！这里是奋斗的小羊，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
💥💥个人主页：奋斗的小羊
💥💥所属专栏：C语言

🚀本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。

目录

  • 前言
  • 一、TOP-K问题
  • 二、二叉树的链式结构
    • 2.1前中后序遍历
    • 2.2节点个数
    • 2.3叶子个数
    • 2.4高度 / 深度
    • 2.5第K层节点数
    • 2.6查找值为x的节点
    • 2.7相关OJ题
  • 总结

前言

在TOP-K问题中有一种方法能在占用很小空间的情况下高效地找出最大或最小的前K个数。
在上篇文章介绍树时说树是递归定义的，因此二叉树的遍历、二叉树的搜索、二叉树的深度、高度、节点数、二叉树的路径求解等问题，基本都会用递归解决。

一、TOP-K问题

接上篇文章，我们简单地了解了TOP-K问题，介绍了如何从比较大的数据量中快速找出最大（最小）的前K个数据。

| 方法一：

用这些较大的数据量建堆，循环Top、Pop，找出最大（最小）的前K个数。

但是这个方法有个致命缺陷，它只适合数据量还不是特别大的情况，因为如果数据量非常大时我们还建堆的话，这对空间的消耗是很大的，那我们就要想别的办法了。如果数据海量，但我们现在只有1GB的内存，直接建堆显然行不通。

| 方法二：

将这海量数据分成合适的若干份分别建堆，找出每份中的最大（最小）的前K的数，再将这些数建堆，循环Top、Pop K次就能找到最大（最小）的前K个数。

但是这个方法也不是特别好，因为1GB的内存还是比较大的，假如这个问题非要搞我们，它有海量的数据但是只给我们1KB的内存，甚至更狠一点只给我们100Byte的空间，这时候方法二就显得力不从心了，因为这个若干份将会非常大，非常不理想。

| 方法三：

先从这海量数据中拿出前K个数建小堆（大堆），然后再不断拿出剩下的数和堆顶数据比较，如果大（小）于堆顶就替换掉堆顶，再向下调整保证堆成立，当这海量的数据全都比完后，留在堆内的数就是这海量数据中最大（最小）的前K个数。

这个方法需要注意的是如果要求我们找最大的前K个数要建小堆，最小的前K个数要建大堆。当然K也不能太大，要是我们现在可用的内存连这K个数都装不下那就有点扯淡了。

方法三代码如下：

void test1()
{
	FILE* pf = fopen("data.txt", "w");
	if (pf == NULL)
	{
		perror("fopen fail");
		return;
	}
	//产生随机的100000个数存到磁盘中
	for (int i = 0; i < 100000; i++)
	{
		//rand函数产生的随机数有重复，+i减少重复的数
		int ret = rand() + i;
		fprintf(pf, "%d\n", ret);
	}

	fclose(pf);
	pf = NULL;
}

void test2()
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen fail");
		return;
	}
	int k = 0;
	scanf("%d", &k);
	int* arr = (int*)malloc(k * sizeof(int));
	if (arr == NULL)
	{
		perror("malloc fail");
		return;
	}
	//读取k个数到数组中
	for (int i = 0; i < k; i++)
	{
		fscanf(pf, "%d", &arr[i]);
	}
	//k个数建小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, i, k);
	}
	//读取剩下的数与堆顶比较
	int ret = 0;
	while (fscanf(pf, "%d", &ret) > 0)
	{
		if (ret > arr[0])
		{
			arr[0] = ret;
			AdjustDown(arr, 0, k);
		}
	}
	//留在堆内的数就是所有数中最大的前K个数
	for (int i = 0; i < k; i++)
	{
		printf("%d ", arr[i]);
	}

	fclose(pf);
	pf = NULL;
}

int main()
{
	srand((unsigned int)time(NULL));
	test1();
	test2();
	return 0;
}

这里又有个问题，我们怎么知道这K个数就是最大的前K个数呢？如何验证？

为了验证我们这个程序有没什么问题，这里有个简单的小方法，我们可以手动地在已经产生了100000个随机数的文件中修改K个使它们一定是最大的K个数，然后再运行程序看看是否有问题。运行前先把产生随机数的函数屏蔽掉。

在这里插入图片描述

可以看到此时打印出来的10个数就是我们故意放进去的最大的10个数。

二、二叉树的链式结构

在上篇文章中简单地了解了二叉树的链式存储，即用链表来表示一棵二叉树，用链表来指示元素的逻辑关系。
通常每个节点由三个域组成，一个数据域和两个指针域，分别用左指针和右指针来指向左孩子和右孩子。链式结构又分为二叉链和三叉链，当前我们学习的是二叉链，三叉链会在后面的学习中学到。

typedef int BTDataType;
//二叉链
typedef struct BinTreeNode
{
	struct BinTreeNode* pleft;//左孩子
	struct BinTreeNode* pright;//右孩子
	BTDataType data;
}BTNode;

二叉树的创建方式比较复杂，后续我们会深入学习，这里为了测试下面将要介绍的二叉树遍历，我们先手动创建一棵链式二叉树。

#define  _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>

typedef int BinTreeType;

typedef struct BinaryTreeNode
{
	BinTreeType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(BinTreeType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return;
	}
	
	node->data = x;
	node->left = node->right = NULL;
	return node;
}

BTNode* GreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

int main()
{
	BTNode* root = GreatBinaryTree();
	return 0;
}

2.1前中后序遍历

在这里插入图片描述

二叉树的操作离不开树的遍历，按照规则，二叉树的遍历有：前序、中序、后序（前根序、中根序、后根序）的递归结构遍历。

  • 前序： 访问顺序为根节点、左子树、右子树

A B D N N N C E N N F N N

  • 中序： 访问顺序为左子树、根节点、右子树

N D N B N A N E N C N F N

  • 后序： 访问顺序为左子树、右子树、根节点

N N D N B N N E N N F C A

代码实现：

void PrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	printf("%d ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

请添加图片描述
请添加图片描述
请添加图片描述

2.2节点个数

如何计算节点的个数呢？可能有同学会想到用上面学到的前中后序遍历二叉树++计数：

int TreeSize(BTNode* root)
{
	int size = 0;
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	size++;
	printf("%d ", root->data);
	TreeSize(root->left);
	TreeSize(root->right);
	return size;
}

但这样是行不通的，因为上面我们前中后序遍历二叉树是递归实现的，每一次递归函数栈帧内都重新定义了size。
那可能又有同学说用static修饰size不就好了，但是这个方法也不太能行得通。

int TreeSize(BTNode* root)
{
	static int size = 0;
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	size++;
	printf("%d ", root->data);
	TreeSize(root->left);
	TreeSize(root->right);
	return size;
}

请添加图片描述

可以看到用static修饰后这个方法也只能计算一次，因为static修饰的变量在静态区，程序运行结束才销毁。
我们可以考虑用递归的思想解决这个问题。因为一个二叉树的节点个数是左子树节点个数+右子树节点个数+1（根节点），左子树的节点个数又是它的左子树节点个数+右子树节点个数+1（根节点），所以我们可以用递归解决这个问题。

在这里插入图片描述

递归计算节点数代码如下：

int TreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return TreeSize(root->left) + TreeSize(root->right) + 1;
}

2.3叶子个数

如果节点的左指针和右指针都指向NULL，那这个节点就是叶子，如果节点为空就返回0。

int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

2.4高度 / 深度

一个二叉树的高度是左子树高度和右子树高度大的一个再加一，左子树的高度又是它的左子树高度和右子树高度大的一个再加一，这显然又是一个递归问题。

int TreeHight(BTNode* root)
{ 
	if (root == NULL)
	{
		return 0;
	}
	int lefthight = TreeHight(root->left);
	int leftright = TreeHight(root->right);
	return lefthight > leftright ? lefthight + 1 : leftright + 1;
}

这里需要注意要用一个值来接收左右子树的高度，不要写成下面这种：

int TreeHight(BTNode* root)
{ 
	if (root == NULL)
	{
		return 0;
	}
	return TreeHight(root->left) > TreeHight(root->right) ? 
	TreeHight(root->left) + 1 : TreeHight(root->right) + 1;
}

虽然下面这种看起来更简单，但是当二叉树的深度比较深时，这个代码的时间消耗是非常非常非常大的。

2.5第K层节点数

求第K层的节点数，就是相对于第二层来说求第K-1层节点数，相对于第三层来说求第K-2层节点数，也可以用递归解决，当节点不为空且K==1时返回1。

int TreeKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return TreeKSize(root->left, k - 1) + TreeKSize(root->right, k - 1);
}

2.6查找值为x的节点

查找值为x的节点可以用前序遍历二叉树解决，当节点值等于x时返回节点指针，如果不等于则查找左子树，如果左子树找到了就返回节点指针，如果没找到（返回NULL）则查找右子树，不管找没找到都返回右子树的返回值。

BTNode* TreeFind(BTNode* root, BinTreeType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* node = TreeFind(root->left, x);
	if (node)//如果为空则左子树没找到
	{
		return node;
	}
	return TreeFind(root->right, x);
}

2.7相关OJ题

Leetcode—单值二叉树

bool isUnivalTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return true;
    }
    if (root->left && root->left->val != root->val)
    {
        return false;
    }
    if (root->right && root->right->val != root->val)
    {
        return false;
    }
    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

Leetcode—相同的树

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if (p == NULL && q == NULL)
    {
        return true;
    }
    if (p == NULL || q == NULL)
    {
        return false;
    }
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) 
    && isSameTree(p->right, q->right);
}

Leetcode—对称二叉树

bool _isSymmetric(struct TreeNode* p, struct TreeNode* q) {
    if (p && q)
    {
        if (p->val != q->val)
        {
            return false;
        }
        return _isSymmetric(p->left, q->right) 
        && _isSymmetric(p->right, q->left);
    }
    if (p == q)
    {
        return true;
    }
    return false;
}
bool isSymmetric(struct TreeNode* root) {
    if (root == NULL)
    {
        return true;
    }
    return _isSymmetric(root->left, root->right);
}

Leetcode—二叉树的前序遍历

int TreeSize(struct TreeNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    return TreeSize(root->left) + TreeSize(root->right) + 1;
}
void PreOrder(struct TreeNode* root, int* arr, int* pi)
{
    if (root == NULL)
    {
        return;
    }
    //每次递归都会建立新的栈帧空间，不同的栈帧空间内相同的变量之间互不影响，
    //而我们需要的是每次函数递归都要改变下标，所以需要传地址。
    arr[(*pi)++] = root->val;
    PreOrder(root->left, arr, pi);
    PreOrder(root->right, arr, pi);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    *returnSize = TreeSize(root);
    //在开辟空间前可以先算出节点个数以开辟合适的空间
    int* arr = (int*)malloc(*returnSize * sizeof(int));
    int i = 0;
    PreOrder(root, arr, &i);
    return arr;
}

函数每次递归都会建立独立的栈帧空间，同一个变量在不同的栈帧空间中互不影响，如果我们想让某一变量在每次函数递归都改变，则应该传变量地址。
Leetcode—另一棵树的子树

bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    if (p == NULL && q == NULL)
    {
        return true;
    }
    if (p == NULL || q == NULL)
    {
        return false;
    }
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) && 
    	isSameTree(p->right, q->right);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
    if (root == NULL)
    {
        return false;
    }
    if (root->val == subRoot->val && isSameTree(root, subRoot))
    {
        return true;
    }
    return isSubtree(root->left, subRoot) || 
    	isSubtree(root->right, subRoot);
}

我们知道二叉树是由根节点和左右子树构成，因此我们可以先判断两个根节点是否相等，如果相等且左右子树也相等则两个二叉树互为子树；如果根节点不相等则递归判断左子树或右子树。

总结

  • 二叉树由根节点、左子树和右子树组成，每个子树也是一个二叉树。递归方法很适合处理这种具有递归结构的数据结构，例如通过递归函数不断地遍历左右子树。递归的思想可以帮助我们分解复杂问题，将大问题转化为相同结构的小问题，从而简化解题过程。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1934170.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

QT CNA上位机报错 解决方案

QT CNA上位机报错 解决方案

QT编译报错: -lControlCAN 解决方案 更换三个文件&#xff0c;即可解决(QT 自带的是32位库&#xff0c;应使用64位库文件)
阅读更多...
Linux系统编程---Make/MakeFile

Linux系统编程---Make/MakeFile

认识make/makefile make是一个命令 makefile是一个当前目录下的文件。 make会自动推导makefile中的依赖关系&#xff0c;栈式结构。形成可执行文件 如何清理 在makefile文件里加上clean&#xff0c;运行时直接make clean&#xff0c;建议clean放在后面。 在没有改变源文件的…
阅读更多...
深入学习STL标准模板库

深入学习STL标准模板库

C STL standard template libaray 标准模板库 目录 C STL standard template libaray 标准模板库 一、标准容器顺序容器vectordequelistvector deque list对比 容器适配器stackqueuepriority_queue 关联容器unordered_setunordered_multisetunordered_mapunordered_multimapset…
阅读更多...
【C++基础】类和对象(4)

【C++基础】类和对象(4)

目录 一、再探构造函数 1.1 构造函数体赋值 1.2 初始化列表 二、类型转换 三、static成员 概念&#xff1a; 特性&#xff1a; 四、友元 4.1 友元函数 4.2 友元类 五、内部类 六、匿名对象 七、对象拷贝时的编译器优化 一、再探构造函数 1.1 构造函数体赋值 …
阅读更多...
Admin.NET源码学习（2：安装并运行前端）

Admin.NET源码学习（2：安装并运行前端）

根据Admin.NET的GitHub主页介绍&#xff0c;前端运行步骤需要运行pnpm命令。百度pnpm的话&#xff0c;需要支持npm相关的命令支持。   根据参考文献4&#xff0c;安装Node.js后会提供npm命令支持&#xff08;npm是Node.js的软件包管理器&#xff0c;用于安装、发布和共享Jav…
阅读更多...
在Linux系统安装MySQL有多简单

在Linux系统安装MySQL有多简单

MySQL 是一种流行的开源关系数据库管理系统&#xff0c;广泛应用于各种类型的应用程序和服务。在安装TitanIDE​​​​​​​以后是没有MySQL服务的&#xff0c;我们需要单独安装安装MySQL。本文将介绍在 Linux 上安装 MySQL 的多种方式&#xff0c;包括离线安装、使用 Docker …
阅读更多...
纤丝龙：强根固发，滋养头皮的天然秘诀

纤丝龙：强根固发，滋养头皮的天然秘诀

在我国传统中医学中&#xff0c;头发被视为“血之余&#xff0c;肾之华”&#xff0c;其生长与健康状况直接反映了人体的精神面貌和生命力。然而&#xff0c;现代生活节奏加快&#xff0c;压力不断增大&#xff0c;导致许多人出现头发干枯、分叉、脱落等问题。纤丝龙&#xff0…
阅读更多...
“轻、灵、画、韵”，TCL第三代艺术电视引领艺术生活

“轻、灵、画、韵”，TCL第三代艺术电视引领艺术生活

7月17日&#xff0c;TCL第三代艺术电视A300系列正式上市&#xff0c;其中&#xff0c;A300 Pro配备B&O音响&#xff0c;共有65/75/85三个尺寸&#xff0c;首发到手价分别为8999元、11999元和15999元。不带Soundbar的A300W&#xff0c;它有55/65/75/85四个尺寸&#xff0c;首…
阅读更多...
volatile关键字解析

volatile关键字解析

一、volatile介绍 volatile是Java提供的一种轻量级的同步机制&#xff0c;在并发编程中&#xff0c;它也扮演着比较重要的角色。同synchronized相比&#xff08;synchronized通常称为重量级锁&#xff09;&#xff0c;volatile更轻量级&#xff0c;相比使用synchronized所带来的…
阅读更多...
Python 读取esxi上所有主机的设备信息

Python 读取esxi上所有主机的设备信息

&#xff08;主要是为了统计所有虚拟机的设备名称和所属主机&#xff09; 代码&#xff1a; from pyVim import connect from pyVmomi import vim import ssldef get_vm_devices(vm):devices []try:if vm.config is not None and hasattr(vm.config, hardware) and hasattr(v…
阅读更多...
JavaWeb入门程序解析（Spring官方骨架、配置起步依赖、SpringBoot父工程、内嵌Tomcat）

JavaWeb入门程序解析（Spring官方骨架、配置起步依赖、SpringBoot父工程、内嵌Tomcat）

3.3 入门程序解析 关于web开发的基础知识&#xff0c;我们可以告一段落了。下面呢&#xff0c;我们在基于今天的核心技术点SpringBoot快速入门案例进行分析。 3.3.1 Spring官方骨架 之前我们创建的SpringBoot入门案例&#xff0c;是基于Spring官方提供的骨架实现的。 Sprin…
阅读更多...
gite+picgo+typora打造个人免费笔记软件

gite+picgo+typora打造个人免费笔记软件

文章目录 1️⃣个人笔记软件2️⃣ 配置教程2.1 使用软件2.2 node 环境配置2.3 软件安装2.4 gite仓库设置2.5 配置picgo2.6 测试检验2.7 github教程 &#x1f3a1; 完结撒花 1️⃣个人笔记软件 最近换了环境&#xff0c;没有之前的生产环境舒适&#xff0c;写笔记也没有劲头&…
阅读更多...
R语言实现对模型的参数优化与评价KS曲线、ROC曲线、深度学习模型训练、交叉验证、网格搜索

R语言实现对模型的参数优化与评价KS曲线、ROC曲线、深度学习模型训练、交叉验证、网格搜索

目录 一、模型性能评估 1、数据预测评估 2、概率预测评估 二、模型参数优化 1、训练集、验证集、测试集的引入 2、k折线交叉验证 2、网格搜索 一、模型性能评估 1、数据预测评估 ### 数据预测评估 #### 加载包&#xff0c;不存在就进行在线下载后加载if(!require(mlben…
阅读更多...
VMware Vsphere创建虚拟机

VMware Vsphere创建虚拟机

作者&#xff1a;红米 一、上传系统镜像 1、打开数据中心 2、新建文件夹&#xff0c;存放镜像 3、点击上传文件按钮 4、找到本地镜像上传 二、安装虚拟机 1、创建虚拟机 2、选择创建类型 3、为虚拟机命名并选择虚拟机安装的所在位置 4、选择计算资源 5、选择存储 6、选择兼容…
阅读更多...
微服务

微服务

微服务 SpringCloud的五大组件 eureka服务注册和发现 nacos的工作流程 nacos和eureka的区别 负载均衡 ribbon负载均衡策略 如何自定义负载策略 服务雪崩 服务熔断 为服务端监控 项目中的限流 seata xa模式 AT模式 tcc模式 分布式服务接口幂等 分布式任务调度
阅读更多...
2024年CSP-J暑假冲刺训练营(1)：分析往年真题

2024年CSP-J暑假冲刺训练营(1)：分析往年真题

考纲大览 一、往年真题1. 2019-2023 真题2. 整体分析 二、类型分析三、押题 一、往年真题 1. 2019-2023 真题 2. 整体分析 首先大家一定要明确&#xff0c;CSP-J 是不会给大家占便宜的&#xff0c;所以大家可以看到&#xff0c;即使被标注了"入门"难度的题目&#…
阅读更多...
【性能测试】第二节.loadrunner工具介绍（LR）

【性能测试】第二节.loadrunner工具介绍（LR）

文章目录 前言一、VUG&#xff1a;虚拟用户发生器 1.1 实现作用 1.2 创建一个新的性能测试脚本 1.3 打开LR自带的web系统 1.4 编写性能测试脚本流程方法 1.5 性能测试脚本的增强二、Controller 2.1 基础功能介绍 2.2 Design 2.3 Run三…
阅读更多...
＜Qt＞ 信号和槽

＜Qt＞ 信号和槽

目录 一、信号和槽概述 二、信号和槽的使用​​​​​​ &#xff08;一&#xff09;connect函数 &#xff08;二&#xff09;实现一个点击按钮关闭窗口的功能 &#xff08;三&#xff09;再谈connect 三、自定义槽函数 四、自定义信号 五、带参数的信号和槽 六、信号…
阅读更多...
Clonezilla 备份还原过程推送日志到 syslog

Clonezilla 备份还原过程推送日志到 syslog

Clonezilla 备份、还原过程中&#xff0c;系统的运行日志只能显示到客户端显示器上&#xff0c;如果出现错误&#xff0c;无法在服务端查询到对应的日志&#xff0c;一是故障判断不太方便&#xff1b;另一方面&#xff0c;实现日志推送&#xff0c;也可以将 Clonezilla 运行进度…
阅读更多...
【前端】ikun-qrcode：极简的二维码生成组件，使用view而非canvas避免层级问题

【前端】ikun-qrcode：极简的二维码生成组件，使用view而非canvas避免层级问题

文章目录 背景ikun-qrcode界面效果如何发布一款自己的插件到uniapp市场。&#xff08;5分钟搞定&#xff09; 背景 之前在uniapp上100行搞定二维码生成&#xff0c; 现在封装为vue组件分享出来&#xff1a; 下载地址&#xff1a; https://ext.dcloud.net.cn/plugin?id19351 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023