【C语言】二叉树的实现

news2024/11/15 8:39:36

文章目录

  • 前言
  • ⭐一、二叉树的定义
  • 🚲二、创建二叉树
  • 🎡三、二叉树的销毁
  • 🎉四、遍历二叉树
    • 1. 前序遍历
    • 2. 中序遍历
    • 3. 后序遍历
    • 4. 层序遍历
  • 🌲五、二叉树的计算
    • 1. 计算二叉树结点个数
    • 2. 计算二叉树叶子结点的个数
    • 3. 计算二叉树的深度
    • 4. 计算二叉树第k层的结点个数
    • 5. 查找二叉树中值为x的结点
    • 6. 判断二叉树是否为完全二叉树
  • 🏝️六、整体代码展示

前言

在学习二叉树实现时，我们首先要对二叉树基本认识有一定的了解，下面我总结了以下几点有关二叉树的性质以及特点：
🎈每一个节点最多有两棵子树，不存在度大于2的节点。
🎈左右子树是有顺序的，其次序不能颠倒。
🎈二叉树一般有四种形态，分别为：空二叉树，只有一个根节点，根结点只有左子树和根节点只有右子树。
🎈二叉树常用的三种性质：1)二叉树的第 i 层上最多有2 ^ (i - 1)个节点；
2)深度为K的二叉树最多有2 ^ (k - 1)个节点。
3)度为0的节点个数比度为2的节点个数多一个。

⭐一、二叉树的定义

二叉树通常以结构体的形式定义，其结构体内容包括三部分：本节点所存储的值、左孩子节点的指针以及右孩子节点的指针。这里需要注意，子节点必须使用指针，就像我们定义结构体链表一样，下一个节点必须使用地址的方式存在在结构体当中。

typedef int BTDateType;

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

🚲二、创建二叉树

当我们对二叉树的掌握还不够深入时，我们也可以创建一棵简单的二叉树，减少时间成本。

// 手搓一个二叉树
BTNode* BuyNode(int x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	node->data = x;
	node->left = NULL;
	node->right = NULL;
}

BTNode* CreatBinaryTree()
{
	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;
}

而真正的二叉树创建的过程是这样的：首先给出一个数组，将要创建的元素放在数组里。然后通过遍历（前 或 中 或 后序遍历）的顺序访问并创建二叉树每个节点，最后返回根节点的地址即创建完成。
我们假设通过前序序列的方式访问并创建二叉树：

// 创建树,按前序遍历的顺序
BTNode* BinaryTreeCreate(BTDateType* a, int* pi) {

	if (a[*pi] != '#') // '#'代表叶子结点
	{
		BTNode* root = (BTNode*)malloc(sizeof(BTNode));
		root->data = a[*pi];
		(*pi)++;
		root->left = BinaryTreeCreate(a, pi);
		(*pi)++;
		root->right = BinaryTreeCreate(a, pi);
		return root;
	}
	else 
	{
		return NULL;
	}
}

🎡三、二叉树的销毁

// 销毁
void BinaryTreeDestory(BTNode* root)
{
	if (root)
	{
		BinaryTreeDestory(root->left);
		BinaryTreeDestory(root->right);
		free(root);
		root = NULL;
	}
}

🎉四、遍历二叉树

在这里插入图片描述
前序遍历，中序遍历和后序遍历，实际上就是指根节点在子节点的先中后的顺序不同。以上图为例：
前序序列：A、B、D、E、H、C、F、G

中序遍历：D、B、H、E、A、F、C、G

后序遍历：D、H、E、B、F、G、C、A

这三种遍历方式，在代码上面还是非常相似的，只不过递归的顺序不同。

1. 前序遍历

先遍历根结点，再遍历左子树，最后遍历右子树。

// 前序遍历
void PrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N "); //打印空节点数据
		return;
	}
	printf("%d ", root->data); // 输出节点数据
	PrevOrder(root->left); //递归遍历左子树节点的数据
	PrevOrder(root->right); //递归遍历右子树节点的数据
}

2. 中序遍历

先遍历左子树，再遍历根结点，最后遍历右子树。

// 中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N "); //打印空节点数据
		return;
	}
	InOrder(root->left); //递归遍历左子树节点的数据
	printf("%d ", root->data); //输出节点数据
	InOrder(root->right); //递归遍历右子树节点的数据
}

3. 后序遍历

先遍历左子树，再遍历右子树，最后遍历根结点。

// 后序遍历
void EndingepilogueOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N "); //打印空节点数据
		return;
	}
	EndingepiloguePrevOrder(root->left); //递归遍历左子树节点的数据
	EndingepiloguePrevOrder(root->right); //递归遍历右子树节点的数据
	printf("%d ", root->data); //输出节点数据
}

4. 层序遍历

层序遍历的做法和上述遍历做法不同，不能简单的调用递归来遍历，而是要借用到队列来辅助实现。队列的实现我就不在叙述了，层序遍历代码所示：

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Quene q;
	QueneInit(&q);
	if (root)
	{
		QuenePush(&q, root); //存入根节点
	}
	while (!QueneEmpty(&q)) //队列不为空就循环
	{
		BTNode* front = QueneFront(&q); //取出队列中的第一个节点
		QuenePop(&q); //删除第一个节点
		printf("%d ", front->data); //打印取出来第一个节点的数据
		if (front->left)
		{
			QuenePush(&q, front->left); //如果左子树不为空，就将左子树存入队列
		}
		if (front->right)
		{
			QuenePush(&q, front->right); //如果右子树不为空，就将右子树存入队列
		}
	}
	QueneDesTroy(&q);
}

🌲五、二叉树的计算

1. 计算二叉树结点个数

计算二叉树的结点个数，只需要将左子树的结点个数加上右子树的结点个数，最后再加上根结点就完成了。

int TreeSide(BTNode* root)
{
	return root == NULL ? 0 : TreeSide(root->left) + TreeSide(root->right) + 1; //运用条件表达式，如果根结点为空就返回0，否则就递归调用遍历左子树和右子树的结点个数，两者相加，最后再加一个最上面的根结点。
}

2. 计算二叉树叶子结点的个数

首先要明白什么是叶子结点，实际上就是度为0的结点即孩子结点。
在这里插入图片描述
如上图，D、H、F、G都为叶子结点。代码展示：

int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0; //空树返回0
	}
	else if (TreeLeafSize(root->left)== NULL && TreeLeafSize(root->right) == NULL)
	{
		return 1; //只含有根节点就返回1
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right); ///递归调用遍历左子树和右子树的叶子数，两者相加
}

3. 计算二叉树的深度

什么是二叉树的深度呢？简单的来说就是左子树或者右子树的深度+1。

// 求树的深度
int TreeHight(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	int highleft = TreeHight(root->left); //获取左子树的深度
	int highright = TreeHight(root->right); //获得右子树的深度
	return highleft > highright ? highleft + 1 : highright + 1; //运用条件表达式，返回左子树和右子树中较大的深度+1
}

4. 计算二叉树第k层的结点个数

实现这一操作的核心思路，就是要知道：求当前树的第k层结点个数 = 左子树的第k - 1层的结点个数 + 右子树的第k-1层的结点个数。

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0; // 空树返回0
	}
	if (k == 1)
	{
		return 1; //第一层为根节点返回1
	}
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

5. 查找二叉树中值为x的结点

这里需要注意的是，我们要记录查找到的结点，否则当我们想要返回所找到的结点数据，却发现又要重新递归去找，时间会消耗好几倍，因此需要记录找到的结点数据

BTNode* BinaryTreeFind(BTNode* root, BTDateType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* left = BinaryTreeFind(root->left, x);
	if (left != NULL)
		return left;
	BTNode* right = BinaryTreeFind(root->right, x);
	if (right != NULL)
		return right;

	// 左右子树都没有
	return NULL;
}

6. 判断二叉树是否为完全二叉树

按照层序遍历的方式遍历完全二叉树，当我们遍历到空结点时，就开始判断。如果队列中还有空，就不是完全二叉树

// 判断二叉树是否为完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
	Quene q;
	QueneInit(&q);
	if (root)
	{
		QuenePush(&q, root);
	}
	while (!QueneEmpty(&q))
	{
		BTNode* front = QueneFront(&q);
		QuenePop(&q);
		// 遇到第一个空就开始判断，如果队列中还有空，就不是完全二叉树
		if (front == NULL)
		{
			break;
		}
		QuenePush(&q, front->left);
		QuenePush(&q, front->right);
	}
	while (!QueneEmpty(&q))
	{
		BTNode* front = QueneFront(&q);
		QuenePop(&q);
		// 如果有非空，就不是完全二叉树
		if (front)
		{
			QueneDesTroy(&q);
			return false;
		}
	}
	QueneDesTroy(&q);
	return true;
}

🏝️六、整体代码展示

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include "Quene.h"

typedef int BTDateType;

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

// 手搓一个二叉树

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

BTNode* CreatBinaryTree()
{
	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;
}

// 销毁
void BinaryTreeDestory(BTNode* root)
{
	if (root)
	{
		BinaryTreeDestory(root->left);
		BinaryTreeDestory(root->right);
		free(root);
		root = NULL;
	}
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Quene q;
	QueneInit(&q);
	if (root)
	{
		QuenePush(&q, root);
	}
	while (!QueneEmpty(&q))
	{
		BTNode* front = QueneFront(&q);
		QuenePop(&q);
		printf("%d ", front->data);
		if (front->left)
		{
			QuenePush(&q, front->left);
		}
		if (front->right)
		{
			QuenePush(&q, front->right);
		}
	}
	QueneDesTroy(&q);
}

// 前序遍历
void PrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

// 中序遍历
void InPrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InPrevOrder(root->left);
	printf("%d ", root->data);
	InPrevOrder(root->right);
}

// 后序遍历
void EndingepiloguePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	EndingepiloguePrevOrder(root->left);
	EndingepiloguePrevOrder(root->right);
	printf("%d ", root->data);
}

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

// 求叶子结点的个数
int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else if (TreeLeafSize(root->left)== NULL && TreeLeafSize(root->right) == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

// 求树的深度
int TreeHight(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	int highleft = TreeHight(root->left);
	int highright = TreeHight(root->right);
	return highleft > highright ? highleft + 1 : highright + 1;
}

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDateType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* left = BinaryTreeFind(root->left, x);
	if (left != NULL)
		return left;
	BTNode* right = BinaryTreeFind(root->right, x);
	if (right != NULL)
		return right;

	// 左右子树都没有
	return NULL;
}

// 判断二叉树是否为完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
	Quene q;
	QueneInit(&q);
	if (root)
	{
		QuenePush(&q, root);
	}
	while (!QueneEmpty(&q))
	{
		BTNode* front = QueneFront(&q);
		QuenePop(&q);
		// 遇到第一个空就开始判断，如果队列中还有空，就不是完全二叉树
		if (front == NULL)
		{
			break;
		}
		QuenePush(&q, front->left);
		QuenePush(&q, front->right);
	}
	while (!QueneEmpty(&q))
	{
		BTNode* front = QueneFront(&q);
		QuenePop(&q);
		// 如果有非空，就不是完全二叉树
		if (front)
		{
			QueneDesTroy(&q);
			return false;
		}
	}
	QueneDesTroy(&q);
	return true;
}

int main()
{
	BTNode* root = CreatBinaryTree();
	PrevOrder(root);
	printf("\n");
	InPrevOrder(root);
	printf("\n");
	EndingepiloguePrevOrder(root);
	printf("\n");
	printf("TreeSide:%d\n", TreeSide(root));
	printf("TreeLeafSize:%d\n", TreeLeafSize(root));
	printf("TreeHight:%d\n", TreeHight(root));
	printf("BinaryTreeFind:%p\n", BinaryTreeFind(root,3));
	printf("BinaryTreeLevelKSize:%d\n", BinaryTreeLevelKSize(root, 3));
	printf("\n");
	BinaryTreeLevelOrder(root);
	
	return 0;
}

今天的分享就到这里啦，如果感觉内容不错，记得一键三连噢。创作不易，感谢大家的支持，我们下次再见！ヾ(￣▽￣)ByeBye

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

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

相关文章

Spring Boot Interceptor（拦截器使用及原理）

Spring Boot Interceptor（拦截器使用及原理）

之前的博客中讲解了关于 Spring AOP的思想和原理&#xff0c;而实际开发中Spring Boot对于AOP的思想的具体实现就是Spring Boot Interceptor。在 Spring Boot 应用程序开发中&#xff0c;拦截器&#xff08;Interceptor&#xff09;是一个非常有用的工具。它允许我们在 HTTP 请…
阅读更多...
kali基本扫描工具(自带)

kali基本扫描工具(自带)

免责声明:本文仅做技术交流与学习...请勿非法破坏... 详细用法: 命令 -h/百度/翻译 fping 用法 hostlist 文件里面为ip fping -a -q -f hostlist -a 只看存活的 fping -g 202.100.1.1 202.100.1.255 -a -q > Ahost 输出到Ahost文件上 nping nping -c 1 201.100.2.155-244 …
阅读更多...
动态规划之背包问题中如何确定遍历顺序的问题-组合or排列？

动态规划之背包问题中如何确定遍历顺序的问题-组合or排列？

关于如何确定遍历顺序 322. 零钱兑换中&#xff0c;本题求钱币最小个数&#xff0c;那么钱币有顺序和没有顺序都可以&#xff0c;都不影响钱币的最小个数。 所以本题并不强调集合是组合还是排列。 如果求组合数就是外层for循环遍历物品&#xff0c;内层for遍历背包。 如果求…
阅读更多...
【数据结构】二叉树的认识与实现

【数据结构】二叉树的认识与实现

目录 二叉树的概念&#xff1a; 二叉树的应用与实现&#xff1a; 二叉树实现接口&#xff1a; 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树 二叉树节点个数​编辑 二叉树叶子节点个数 二叉树第k层节点个数 二叉树查找值为x的节点​编辑 二叉树前序遍…
阅读更多...
Day 3：1738. 找出第 K 大的异或坐标值

Day 3：1738. 找出第 K 大的异或坐标值

Leetcode 1738. 找出第 K 大的异或坐标值 给你一个二维矩阵 matrix 和一个整数 k &#xff0c;矩阵大小为 m x n 由非负整数组成。 矩阵中坐标 (a, b) 的 值 可由对所有满足 0 < i < a < m 且 0 < j < b < n 的元素 matrix[i][j]&#xff08;下标从 0 开始计…
阅读更多...
【Linux】进程通信实战 —— 进程池项目

【Linux】进程通信实战 —— 进程池项目

送给大家一句话: 没有一颗星&#xff0c;会因为追求梦想而受伤&#xff0c;当你真心渴望某样东西时&#xff0c;整个宇宙都会来帮忙。 – 保罗・戈埃罗 《牧羊少年奇幻之旅》 &#x1f3d5;️&#x1f3d5;️&#x1f3d5;️&#x1f3d5;️&#x1f3d5;️&#x1f3d5;️ &a…
阅读更多...
# linux 系统 没有 ifconfig 命令，提示： ifconfig: command not found

# linux 系统 没有 ifconfig 命令，提示： ifconfig: command not found

sudo ip route add default via 192.168.1.1 dev eth0# linux 系统 没有 ifconfig 命令&#xff0c;提示&#xff1a; ifconfig: command not found 一、问题描述&#xff1a; 有些伙伴在学习 linux 系统时&#xff0c;在 使用 ifconfig 命令 查询 系统 IP 出现 ifconfig: co…
阅读更多...
【LakeHouse】Apache Iceberg + Amoro 助力网易构建云原生湖仓

【LakeHouse】Apache Iceberg + Amoro 助力网易构建云原生湖仓

Apache Iceberg Amoro 助力网易构建云原生湖仓 1.云原生湖仓背景与挑战2.Apache Iceberg 、Amoro 与云原生2.1 Apache Iceberg2.2 Amoro 简介 3.Apache Iceberg Amoro 云原生实践3.1 云上湖仓案例一3.2 云上湖仓案例二3.3 云上湖仓案例三 4.Amoro 未来发展规划 出品社区&…
阅读更多...
上百个神奇有趣的小工具，总有一款适合你

上百个神奇有趣的小工具，总有一款适合你

这几天了不起在逛 GitHub 时&#xff0c;发现了一个有趣的项目——MikuTools。这是一个工具集合的 web 项目&#xff0c;提供了上百个有趣实用神奇的工具。 项目简介 MikuTools 项目主页的介绍很简单&#xff1a;一个轻量的工具集合。确实&#xff0c;项目界面非常简洁&#…
阅读更多...
免费图片文字转换成文本，ocr文字识别软件免费版，真的太实用了！

免费图片文字转换成文本，ocr文字识别软件免费版，真的太实用了！

截屏短视频上一段扎心文字&#xff0c;想把它发到朋友圈怎么办&#xff1f;这时候就需要一个OCR识别软件。 它就像一个聪明的小助手&#xff0c;它可以帮助电脑“看懂”书本上或者图片里的字。就像我们用眼睛看字一样&#xff0c;OCR软件用它的“眼睛”扫描图片&#xff0c;识…
阅读更多...
企业活动想找媒体报道宣传怎样联系媒体？

企业活动想找媒体报道宣传怎样联系媒体？

在那遥远的公关江湖里,有一个传说,说的是一位勇士,手持鼠标和键盘,踏上了寻找媒体圣杯的征途。这位勇士,就是我们亲爱的市场部门小李,他的任务是为公司即将举行的一场盛大的企业活动找到媒体的聚光灯。 小李的故事,开始于一张空白的Excel表格,上面列着各大媒体的名称,旁边是一片…
阅读更多...
面试题·栈和队列的相互实现·详解

面试题·栈和队列的相互实现·详解

A. 用队列实现栈 用队列实现栈 实现代码如下 看着是队列&#xff0c;其实实际实现更接近数组模拟 typedef struct {int* queue1; // 第一个队列int* queue2; // 第二个队列int size; // 栈的大小int front1, rear1, front2, rear2; // 两个队列的首尾指针 } MyS…
阅读更多...
gfast：基于全新Go Frame 2.3+Vue3+Element Plus构建的全栈前后端分离管理系统

gfast：基于全新Go Frame 2.3+Vue3+Element Plus构建的全栈前后端分离管理系统

gfast&#xff1a;基于全新Go Frame 2.3Vue3Element Plus构建的全栈前后端分离管理系统 随着信息技术的飞速发展和数字化转型的深入&#xff0c;后台管理系统在企业信息化建设中扮演着越来越重要的角色。为了满足市场对于高效、灵活、安全后台管理系统的需求&#xff0c;gfast应…
阅读更多...
ICQ 将于 6 月关闭，这是一种奇怪的方式，发现它在 2024 年仍然活跃

ICQ 将于 6 月关闭，这是一种奇怪的方式，发现它在 2024 年仍然活跃

你知道ICQ还活着吗&#xff1f;不过&#xff0c;不要太兴奋;它将永远消失。 还记得ICQ吗&#xff1f;如果你这样做了&#xff0c;你可能会记得它是AOL在1998年购买的Messenger客户端&#xff0c;就在Yahoo Instant Messager和MSN Messenger加入竞争的时候。然后Skype出现了&…
阅读更多...
网络模型-BFD与网络协议联动

网络模型-BFD与网络协议联动

一、BFD:双向转发检测 双向转发检测BFD(Bidirectional Forwarding Detection)是一种全网统一的检测机制&#xff0c;用于快速检测、监控网络中链路或者IP路由的转发连通状况。 1、BFD优点: 对相邻转发引擎之间的通道提供轻负荷、快速故障检测。这些故障包括接口数据链路&#…
阅读更多...
g-h Filter 详细讲解

g-h Filter 详细讲解

g-h 过滤器 g-h 滤波器百科介绍。 之前的翻译大家&#xff0c;我看都没什么阅读量&#xff0c;可能大家都不是很想看&#xff08;估计也是我英文太水&#xff09;。那么这篇博客我就先暂停直接翻译原文&#xff0c;而是直接说一下自己的理解。 本文章背后的书的详细介绍可以…
阅读更多...
单片机原理及技术（二）—— AT89S51单片机（一）（C51编程）

单片机原理及技术（二）—— AT89S51单片机（一）（C51编程）

目录 一、AT89S51单片机的片内硬件结构 二、AT89S51的引脚功能 2.1 电源及时钟引脚 2.2 控制引脚 2.3 并行 I/O口引脚 三、AT89S51的CPU 3.1 运算器 3.1.1 算术逻辑单元&#xff08;ALU&#xff09; 3.1.2 累加器A 3.1.3 程序状态字寄存器&#xff08;PSW&#xff09…
阅读更多...
Linux-应用编程学习笔记(三、文件属性和目录)

Linux-应用编程学习笔记(三、文件属性和目录)

一、文件类型 1、普通文件&#xff08;ls -l 文件&#xff0c;权限前边第一个"-"代表普通文件&#xff1b;stat 文件&#xff09; 文本文件&#xff1a;ASCII字符 二进制文件&#xff1a;数字0/1 2、目录文件&#xff08;‘’d&#xff09;&#xff1a;文件夹 3…
阅读更多...
声压级越大，STIPA 越好，公共广播就越清晰吗？

声压级越大，STIPA 越好，公共广播就越清晰吗？

在公共广播中&#xff0c;有些朋友经常问到是不是声压越大&#xff0c;广播清晰度就越高&#xff0c;下面我从搜集了一些专业技术资料&#xff0c;供大家参考。 一、声压级越大&#xff0c;STIPA 越好吗&#xff1f; 不完全是。最初&#xff0c;人们认为当声压级达到 60 dBA 以…
阅读更多...
STL源码刨析：序列式容器之vector

STL源码刨析：序列式容器之vector

目录 1.序列式容器和关联式容器 2.vector的定义和结构 3.vector的构造函数和析构函数的实现 4.vector的数据结构以及实现源码 5.vector的元素操作 前言 本系列将重点对STL中的容器进行讲解&#xff0c;而在容器的分类中&#xff0c;我们将容器分为序列式容器和关联式容器。本章…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023