吐血整理 二叉树(链表实现)的基本操作详解！

news2024/11/15 8:16:58

文章目录

  • 节点设置
  • 二叉树的深度优先遍历
    • 前序遍历
    • 中序遍历
    • 后序遍历
  • 二叉树的广度优先遍历
    • 层序遍历
  • 节点的个数
  • 叶子节点的个数
  • 第K层节点的个数
  • 值为X的节点
  • 树的最大深度
  • 翻转二叉树
  • 判断两颗二叉树是否相同
  • 判断二叉树是否是完全二叉树
  • 判断二叉树是否是单值二叉树
  • 判断二叉树是否是平衡二叉树
  • 判断二叉树是否是对称二叉树
  • 判断一棵二叉树是否是另一棵二叉树的子树
  • 二叉树的销毁
  • 二叉树的深度遍历（接口型题目）
    • 前序遍历
    • 中序遍历
    • 后序遍历
  • 二叉树的构建及遍历

本文是对二叉树这种数据结构基本操作与部分练习题的总结，内容庞大、详细、易懂，是你学习路上不容错过的优质博客！

节点设置

既然是链式二叉树，那必须得有自己的结点类型，以下是链式二叉树结点类型的定义，为了避免过多重复的代码，下面的问题都统一使用该结点类型。

代码示例：

typedef char BTDataType;//结点中存储的元素类型（以char为例）

typedef struct BTNode
{
	BTDataType data;//结点中存储的元素类型
	struct BTNode* left;//左指针域（指向左孩子）
	struct BTNode* right;//右指针域（指向右孩子）
}BTNode;

二叉树的深度优先遍历

图片示例：
在这里插入图片描述

前序遍历

前序遍历，又叫先根遍历。
遍历顺序：根 -> 左子树 -> 右子树

图片示例：
在这里插入图片描述

代码示例：

//前序遍历
void BinaryPrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	//根->左子树->右子树
	printf("%c ", root->data);
	BinaryPrevOrder(root->left);
	BinaryPrevOrder(root->right);
}

中序遍历

中序遍历，又叫中根遍历。
遍历顺序：左子树 -> 根 -> 右子树

图片示例：
在这里插入图片描述

代码示例：

void BinaryInOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	//左子树->根->右子树
	BinaryInOrder(root->left);
	printf("%c ", root->data);
	BinaryInOrder(root->right);
}

后序遍历

后序遍历，又叫后根遍历。
遍历顺序：左子树 -> 右子树 -> 根

图片示例：
在这里插入图片描述

代码示例：

//后序遍历
void BinaryPostOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	//左子树->右子树->根
	BinaryPostOrder(root->left);
	BinaryPostOrder(root->right);
	printf("%c ", root->data);
}

二叉树的广度优先遍历

层序遍历

层序遍历，自上而下，从左往右逐层访问树的结点的过程就是层序遍历。
在这里插入图片描述

思路（借助一个队列）：
 1.先把根入队列，然后开始从队头出数据。
 2.出队头的数据，把它的左孩子和右孩子依次从队尾入队列（NULL不入队列）。
 3.重复进行步骤2，直到队列为空为止。

在这里插入图片描述

特点：借助队列先进先出的性质，上一层数据出队列的时候带入下一层数据。

代码示例：

//层序遍历
void BinaryLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);//初始化队列
	if (root != NULL)
		QueuePush(&q, root);
	while (!QueueEmpty(&q))//当队列不为空时，循环继续
	{
		BTNode* front = QueueFront(&q);//读取队头元素
		QueuePop(&q);//删除队头元素
		printf("%c ", front->data);//打印出队的元素
		if (front->left)
		{
			QueuePush(&q, front->left);//出队元素的左孩子入队列
		}
		if (front->right)
		{
			QueuePush(&q, front->right);//出队元素的右孩子入队列
		}
	}
	QueueDestroy(&q);//销毁队列
}

节点的个数

求解树的结点总数时，可以将问题拆解成子问题：
 1.若为空，则结点个数为0。
 2.若不为空，则结点个数 = 左子树结点个数 + 右子树结点个数 + 1（自己）。

代码示例：

//结点的个数
int BinaryTreeSize(BTNode* root)
{	
	//结点个数 = 左子树的结点个数 + 右子树的结点个数 + 自己
	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

叶子节点的个数

子问题拆解：
 1.若为空，则叶子结点个数为0。
 2.若结点的左指针和右指针均为空，则叶子结点个数为1。
 3.除上述两种情况外，说明该树存在子树，其叶子结点个数 = 左子树的叶子结点个数 + 右子树的叶子结点个数。

代码示例：

//叶子结点的个数
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层节点的个数

思路：
 相对于根结点的第k层结点的个数 = 相对于以其左孩子为根的第k-1层结点的个数 + 相对于以其右孩子为根的第k-1层结点的个数。

在这里插入图片描述

代码示例：

//第k层结点的个数
int BinaryTreeKLevelSize(BTNode* root, int k)
{
	if (k < 1 || root == NULL)//空树或输入k值不合法
		return 0;
	if (k == 1)//第一层结点个数
		return 1;
	//相对于父结点的第k层的结点个数 = 相对于两个孩子结点的第k-1层的结点个数之和
	return BinaryTreeKLevelSize(root->left, k - 1) + BinaryTreeKLevelSize(root->right, k - 1);
}

值为X的节点

子问题：
 1.先判断根结点是否是目标结点。
 2.再去左子树中寻找。
 3.最后去右子树中寻找。

代码示例：

//查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)//空树
		return NULL;
	if (root->data == x)//先判断根结点
		return root;
	BTNode* lret = BinaryTreeFind(root->left, x);//在左子树中找
	if (lret)
		return lret;
	BTNode* rret = BinaryTreeFind(root->right, x);//在右子树中找
	if (rret)
		return rret;
	return NULL;//根结点和左右子树中均没有找到
}

树的最大深度

子问题：
 1.若为空，则深度为0。
 2.若不为空，则树的最大深度 = 左右子树中深度较大的值 + 1。

代码示例：

//求较大值
int Max(int a, int b)
{
	return a > b ? a : b;
}
//树的最大深度
int BinaryTreeMaxDepth(BTNode* root)
{
	if (root == NULL)//空树，深度为0
		return 0;
	//树的最大深度 = 左右子树中深度较大的值 + 1
	return Max(BinaryTreeMaxDepth(root->left), BinaryTreeMaxDepth(root->right)) + 1;
}

翻转二叉树

如何翻转一棵二叉树呢？我们可以先观察一棵二叉树在翻转前后的变化：
在这里插入图片描述

通过观察，可以发现：翻转后，根的左右子树的位置交换了；根的孩子的左右子树的位置也交换了；根的孩子的孩子的左右子树的位置也交换了…

思路：
 1.翻转左子树。
 2.翻转右子树。
 3.交换左右子树的位置。

代码示例：

//翻转二叉树
BTNode* invertTree(BTNode* root)
{
	if (root == NULL)//根为空，直接返回
		return NULL;
	BTNode* left = invertTree(root->left);//翻转左子树
	BTNode* right = invertTree(root->right);//翻转右子树
	//左右子树位置交换
	root->left = right;
	root->right = left;
	return root;
}

判断两颗二叉树是否相同

判断两棵二叉树是否相同，也可以将其分解为子问题：
 1.比较两棵树的根是否相同。
 2.比较两根的左子树是否相同。
 3.比较两根的右子树是否相同。

代码示例：

//判断两棵二叉树是否相同
bool isSameTree(BTNode* p, BTNode* q)
{
	if (p == NULL&&q == NULL)//两棵树均为空，则相同
		return true;
	if (p == NULL || q == NULL)//两棵树中只有一棵树为空，则不相同
		return false;
	if (p->data != q->data)//两棵树根的值不同，则不相同
		return false;
	return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);//两棵树的左子树相同并且右子树相同，则这两棵树相同
}

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

判断二叉树是否是完全二叉树的方法与二叉树的层序遍历类似，但又有一些不同。

思路（借助一个队列）：
 1.先把根入队列，然后开始从队头出数据。
 2.出队头的数据，把它的左孩子和右孩子依次从队尾入队列（NULL也入队列）。
 3.重复进行步骤2，直到读取到的队头数据为NULL时停止入队列。
 4.检查队列中剩余数据，若全为NULL，则是完全二叉树；若其中有一个非空的数据，则不是完全二叉树。

在这里插入图片描述

代码示例：

//判断二叉树是否是完全二叉树
bool isCompleteTree(BTNode* root)
{
	Queue q;
	QueueInit(&q);//初始化队列
	if (root != NULL)
		QueuePush(&q, root);
	while (!QueueEmpty(&q))//当队列不为空时，循环继续
	{
		BTNode* front = QueueFront(&q);//读取队头元素
		QueuePop(&q);//删除队头元素
		if (front == NULL)//当读取到空指针时，停止入队操作
			break;
		QueuePush(&q, front->left);//出队元素的左孩子入队列
		QueuePush(&q, front->right);//出队元素的右孩子入队列
	}
	while (!QueueEmpty(&q))//读取队列中剩余的数据
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front != NULL)//若队列中存在非空指针，则不是完全二叉树
		{
			QueueDestroy(&q);//销毁队列
			return false;
		}
	}
	QueueDestroy(&q);//销毁队列
	return true;//若队列中全是空指针，则是完全二叉树
}

判断二叉树是否是单值二叉树

单值二叉树，所有结点的值都相同的二叉树即为单值二叉树，判断某一棵二叉树是否是单值二叉树的一般步骤如下：
 1.判断根的左孩子的值与根结点是否相同。
 2.判断根的右孩子的值与根结点是否相同。
 3.判断以根的左孩子为根的二叉树是否是单值二叉树。
 4.判断以根的右孩子为根的二叉树是否是单值二叉树。
若满足以上情况，则是单值二叉树。

注：空树也是单值二叉树。

代码示例：

//判断二叉树是否是单值二叉树
bool isUnivalTree(BTNode* root)
{
	if (root == NULL)//根为空，是单值二叉树
		return true;
	if (root->left && root->left->data != root->data)//左孩子存在，但左孩子的值不等于根的值
		return false;
	if (root->right && root->right->data != root->data)//右孩子存在，但右孩子的值不等于根的值
		return false;
	return isUnivalTree(root->left) && isUnivalTree(root->right);//左子树是单值二叉树并且右子树是单值二叉树
}

判断二叉树是否是平衡二叉树

若一棵二叉树的每个结点的左右两个子树的高度差的绝对值不超过1，则称该树为平衡二叉树。
在这里插入图片描述

思路一：
子问题：
 1.求出左子树的深度。
 2.求出右子树的深度。
 3.若左子树与右子树的深度差的绝对值不超过1，并且左右子树也是平衡二叉树，则该树是平衡二叉树。

代码示例：

//判断二叉树是否是平衡二叉树
bool isBalanced(BTNode* root)
{
	if (root == NULL)//空树是平衡二叉树
		return true;

	int leftDepth = BinaryTreeMaxDepth(root->left);//求左子树的深度
	int rightDepth = BinaryTreeMaxDepth(root->right);//求右子树的深度
	//左右子树高度差的绝对值不超过1 && 其左子树是平衡二叉树 && 其右子树是平衡二叉树
	return abs(leftDepth - rightDepth) < 2 && isBalanced(root->left) && isBalanced(root->right);
}

时间复杂度：O(N^2)

思路二：
采用后序遍历：
 1.从叶子结点处开始计算每课子树的高度。（每棵子树的高度 = 左右子树中高度的较大值 + 1）
 2.先判断左子树是否是平衡二叉树。
 3.再判断右子树是否是平衡二叉树。
 4.若左右子树均为平衡二叉树，则返回当前子树的高度给上一层，继续判断上一层的子树是否是平衡二叉树，直到判断到根为止。（若判断过程中，某一棵子树不是平衡二叉树，则该树也就不是平衡二叉树了）

在这里插入图片描述

代码示例：

bool _isBalanced(BTNode* root, int* ph)
{
	if (root == NULL)//空树是平衡二叉树
	{
		*ph = 0;//空树返回高度为0
		return true;
	}
	//先判断左子树
	int leftHight = 0;
	if (_isBalanced(root->left, &leftHight) == false)
		return false;
	//再判断右子树
	int rightHight = 0;
	if (_isBalanced(root->right, &rightHight) == false)
		return false;
	//把左右子树的高度中的较大值+1作为当前树的高度返回给上一层
	*ph = Max(leftHight, rightHight) + 1;

	return abs(leftHight - rightHight) < 2;//平衡二叉树的条件
}
//判断二叉树是否是平衡二叉树
bool isBalanced(BTNode* root)
{
	int hight = 0;
	return _isBalanced(root, &hight);
}

时间复杂度：O(N)

判断二叉树是否是对称二叉树

对称二叉树，这里所说的对称是指镜像对称：
在这里插入图片描述

要判断某二叉树是否是对称二叉树，则判断其根结点的左子树和右子树是否是镜像对称即可。因为是镜像对称，所以左子树的遍历方式和右子树的遍历方式是不同的，准确来说，左子树和右子树的遍历是反方向进行的。
如下图：
在这里插入图片描述

图中红蓝轨迹同时进行，同时结束。若在遍历过程中发现镜像对称的某两个结点值不同，则无需继续遍历，此时已经可以判断该树不是对称二叉树，只有当红蓝轨迹成功遍历完毕后，才能断定该树是对称二叉树。

代码示例：

//判断镜像位置是否相等
bool travel(BTNode* left, BTNode* right)
{
	if (left == NULL&&right == NULL)//红蓝轨迹同时遍历到NULL，函数返回
		return true;
	if (left == NULL || right == NULL)//红蓝指针中，一个为NULL，另一个不为NULL，即镜像不相等
		return false;
	if (left->data != right->data)//红蓝指针指向的结点值不同，即镜像不相等
		return false;
	//子问题：左子树遍历顺序：先左后右，右子树遍历顺序：先右后左。若两次遍历均成功，则是对称二叉树
	return travel(left->left, right->right) && travel(left->right, right->left);
}
//对称二叉树
bool isSymmetric(BTNode* root)
{
	if (root == NULL)//空树是对称二叉树
		return true;
	return travel(root->left, root->right);//判断镜像位置是否相等
}

判断一棵二叉树是否是另一棵二叉树的子树

判断 subRoot 是否是二叉树 root 的子树，即检验 root 中是否包含和 subRoot 具有相同结构和结点值的子树，其中 root 和 subRoot 均为非空二叉树。

如下图中，subRoot就是root的一棵子树：
在这里插入图片描述

思路：
 依次判断以 root 中某一个结点为根的子树是否与subRoot相同。
 在这里插入图片描述

实际上，当发现 root 中的某一个子树与 subRoot 相匹配时，便不再继续比较其他子树，所以图中只会比较到序号2就结束比较了。

代码示例：

//比较以root和subRoot为根结点的两棵树是否相等
bool Compare(BTNode* root, BTNode* subRoot)
{
	if (root == NULL&&subRoot == NULL)//均为空树，相等
		return true;
	if (root == NULL || subRoot == NULL)//一个为空另一个不为空，不相等
		return false;
	if (root->data != subRoot->data)//结点的值不同，不相等
		return false;
	//比较两棵树的子结点
	return Compare(root->left, subRoot->left) && Compare(root->right, subRoot->right);
}
//另一个树的子树
bool isSubtree(BTNode* root, BTNode* subRoot)
{
	if (root == NULL)//空树，不可能是与subRoot相同（subRoot非空）
		return false;
	if (Compare(root, subRoot))//以root和subRoot为根，开始比较两棵树是否相同
		return true;
	//判断root的左孩子和右孩子中是否有某一棵子树与subRoot相同
	return isSubtree(root->left, subRoot) || isSubtree(root->right,subRoot);
}

二叉树的销毁

二叉树的销毁，与其他数据结构的销毁类似，都是一边遍历一边销毁。但是二叉树需要注意销毁结点的顺序，遍历时我们应该选用后序遍历，也就是说，销毁顺序应该为：左子树->右子树->根。
 我们必须先将左右子树销毁，最后再销毁根结点，若先销毁根结点，那么其左右子树就无法找到，也就无法销毁了。

代码示例：

//二叉树销毁
void BinaryTreeDestroy(BTNode* root)
{
	if (root == NULL)
		return;

	BinaryTreeDestroy(root->left);//销毁左子树
	BinaryTreeDestroy(root->right);//销毁右子树
	free(root);//释放根结点
}

二叉树的深度遍历（接口型题目）

注意，接下来所要说的深度遍历与前面有所不同，前面说到的深度遍历是将一棵二叉树遍历，并将遍历结果打印屏幕上（较简单）。而下面说到的深度遍历是将一棵二叉树进行遍历，并将遍历结果存储到一个动态开辟的数组中，将数组作为函数返回值进行返回。

思路：
 1.首先计算二叉树中结点的个数，便于确定动态开辟的数组的大小。
 2.遍历二叉树，将遍历结果存储到数组中。
 3.返回数组。

前序遍历

代码示例：

//求树的结点个数
int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
//将树中结点的值放入数组
void preorder(BTNode* root, int* arr, int* pi)
{
	if (root == NULL)//根结点为空，直接返回
		return;
	arr[(*pi)++] = root->data;//先将根结点的值放入数组
	preorder(root->left, arr, pi);//再将左子树中结点的值放入数组
	preorder(root->right, arr, pi);//最后将右子树中结点的值放入数组
}
//前序遍历
int* preorderTraversal(BTNode* root, int* returnSize)
{
	*returnSize = TreeSize(root);//值的个数等于结点的个数
	int* arr = (int*)malloc(sizeof(int)*(*returnSize));
	int i = 0;
	preorder(root, arr, &i);//将树中结点的值放入数组
	return arr;
}

中序遍历

代码示例：

//求树的结点个数
int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
//将树中结点的值放入数组
void inorder(BTNode* root, int* arr, int* pi)
{
	if (root == NULL)//根结点为空，直接返回
		return;
	inorder(root->left, arr, pi);//先将左子树中结点的值放入数组
	arr[(*pi)++] = root->data;//再将根结点的值放入数组
	inorder(root->right, arr, pi);//最后将右子树中结点的值放入数组
}
//中序遍历
int* inorderTraversal(BTNode* root, int* returnSize)
{
	*returnSize = TreeSize(root);//值的个数等于结点的个数
	int* arr = (int*)malloc(sizeof(int)*(*returnSize));
	int i = 0;
	preorder(root, arr, &i);//将树中结点的值放入数组
	return arr;
}

后序遍历

代码示例：

//求树的结点个数
int TreeSize(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
//将树中结点的值放入数组
void postorder(BTNode* root, int* arr, int* pi)
{
	if (root == NULL)//根结点为空，直接返回
		return;
	postorder(root->left, arr, pi);//先将左子树中结点的值放入数组
	postorder(root->right, arr, pi);//再将右子树中结点的值放入数组
	arr[(*pi)++] = root->data;//最后将根结点的值放入数组
}
//后序遍历
int* postorderTraversal(BTNode* root, int* returnSize)
{
	*returnSize = TreeSize(root);//值的个数等于结点的个数
	int* arr = (int*)malloc(sizeof(int)*(*returnSize));
	int i = 0;
	preorder(root, arr, &i);//将树中结点的值放入数组
	return arr;
}

二叉树的构建及遍历

编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

输入描述：
 输入包括1行字符串，长度不超过100。

输出描述：
 可能有多组测试数据，对于每组数据，输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。每个输出结果占一行。

思路：
 根据前序遍历所得到的字符串，我们可以很容易地将其对应的二叉树画出来。

在这里插入图片描述

其实很容易发现其中的规律，我们可以依次从字符串读取字符：
 1.若该字符不是#，则我们先构建该值的结点，然后递归构建其左子树和右子树。
 2.若该字符是#，则说明该位置之下不能再构建结点了，返回即可。

构建完树后，使用中序遍历打印二叉树的数据即可。

代码示例：

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

typedef struct TreeNode
{
    struct TreeNode* left;
    struct TreeNode* right;
    char data;
}TreeNode;
//创建树
TreeNode* CreateTree(char* str, int* pi)
{
    if(str[*pi] == '#')//
    {
        (*pi)++;
        return NULL;
    }
    //不是NULL，构建结点
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->left = NULL;
    root->right = NULL;
    root->data = str[*pi];
    (*pi)++;
    //递归构建左子树
    root->left = CreateTree(str, pi);
    //递归构建右子树
    root->right = CreateTree(str, pi);
    return root;
}
//中序遍历
void Inorder(TreeNode* root)
{
    if(root == NULL)
        return;
    Inorder(root->left);
    printf("%c ", root->data);
    Inorder(root->right);
}
int main()
{
    char str[100];
    scanf("%s", str);
    int i = 0;
    TreeNode* root = CreateTree(str, &i);
    Inorder(root);
    return 0;
}

如此明了清晰的详解过程，希望各位看官能够一键三连哦💕

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

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

相关文章

有哪些好用的pdf修改器？思路提供

有哪些好用的pdf修改器？思路提供

PDF格式的文档在现代生活中扮演着越来越重要的角色。但是&#xff0c;要编辑或修改PDF文件是一件非常困难的事情&#xff0c;因为PDF文件的格式和内容通常被锁定。为了解决这个问题&#xff0c;出现了PDF修改器这种工具&#xff0c;它可以帮助用户轻松地编辑和修改PDF文件。本文…
阅读更多...
RDK X3 Module发布，全新软硬件平台加速实现量产级产品落地

RDK X3 Module发布，全新软硬件平台加速实现量产级产品落地

机器人开发是一段美妙的旅程。GEEKROS创始人杨状状是地平线社区的一名开发者&#xff0c;热衷于鼓捣各类机器人&#xff0c;2022年&#xff0c;状状第一时间就拿到了地平线旭日X3派&#xff08;简称旭日X3派&#xff09;&#xff0c;基于TogetheROS™.Bot机器人操作系统&#x…
阅读更多...
Win11集成 ChatGPT，任务栏取消分组真的回来了

Win11集成 ChatGPT，任务栏取消分组真的回来了

时隔两月微软如期发布了 Win11 Moments 3 更新&#xff0c;版本号 22621.1778 。 微软这次更新带来了许多质量更新和功能改进。 直观的改动是任务栏&#xff0c;网络图标在连接加密隧道时会上锁&#xff0c;时间显示到秒也重新回归。 日常会用到的 AltTab 任务选项卡被限制到最…
阅读更多...
04_Cenos安装Docker

04_Cenos安装Docker

docker安装文档&#xff1a; ubuntu&#xff1a;https://docs.docker.com/engine/install/ubuntu/ centos&#xff1a;https://docs.docker.com/engine/install/centos/ debian&#xff1a;https://docs.docker.com/engine/install/debian/ cenos安装Docker前提&#xff1a; 必…
阅读更多...
深入理解Linux虚拟内存管理（二）

深入理解Linux虚拟内存管理（二）

系列文章目录 Linux 内核设计与实现 深入理解 Linux 内核&#xff08;一&#xff09; 深入理解 Linux 内核&#xff08;二&#xff09; Linux 设备驱动程序&#xff08;一&#xff09; Linux 设备驱动程序&#xff08;二&#xff09; Linux 设备驱动程序&#xff08;三&#xf…
阅读更多...
生态系统NPP及碳源、碳汇模拟、土地利用变化、未来气候变化、空间动态模拟实践技术

生态系统NPP及碳源、碳汇模拟、土地利用变化、未来气候变化、空间动态模拟实践技术

由于全球变暖、大气中温室气体浓度逐年增加等问题的出现&#xff0c;“双碳”行动特别是碳中和已经在世界范围形成广泛影响。碳中和可以从碳排放&#xff08;碳源&#xff09;和碳固定&#xff08;碳汇&#xff09;这两个侧面来理解。陆地生态系统在全球碳循环过程中有着重要作…
阅读更多...
加盐加密算法

加盐加密算法

文章目录 为什么需要加密&#xff1f;加盐加密MD5盐值加密Spring Security加盐 为什么需要加密&#xff1f; 从下面的图片中&#xff0c;可以看到用户的密码在数据库中存储时&#xff0c;如果不对密码加密&#xff0c;则是以明文的方式存储的&#xff0c;如果被别人获取到数据…
阅读更多...
Mobx和Mobx-react:集中式状态管理

Mobx和Mobx-react:集中式状态管理

一、Mobx (1) Mobx是一个功能强大&#xff0c;上手非常容易的状态管理工具。 (2) Mobx背后的哲学很简单: 任何源自应用状态的东西都应该自动地获得。只获取与自己相关的数据&#xff0c;不获取无关数据&#xff08;redux则相反&#xff09; (3) Mobx利用getter和setter来收集组…
阅读更多...
科技兴警，优云「公安一体化安全运维解决方案」亮相2023警博会

科技兴警，优云「公安一体化安全运维解决方案」亮相2023警博会

日前&#xff0c;第十一届中国国际警用装备博览会&#xff08;警博会&#xff09;在北京首钢会展中心成功举办&#xff0c;600余家企业参展&#xff0c;集中展示国内外前沿警用装备及尖端技术&#xff0c;大力推进警用装备现代化。 国内领先的平台级数字化运维软件服务商广通优…
阅读更多...
TDengine集群搭建

TDengine集群搭建

我这里用三台服务器搭建集群 1、如果搭建集群的物理节点上之前安装过TDengine先卸载清空&#xff0c;直接执行以下4条命令 rmtaos rm -rf /var/lib/taos rm -rf /var/log/taos rm -rf /etc/taos2、确保集群中所有主机开放端口 6030-6043/tcp&#xff0c;6060/tcp&#xff0c;…
阅读更多...
flink的几种source来源

flink的几种source来源

简单的总结了flink的几种source来源&#xff0c;可以参考下 package com.atguigu.apitestimport java.util.Propertiesimport org.apache.flink.api.common.serialization.SimpleStringSchema import org.apache.flink.streaming.api.functions.source.SourceFunction import …
阅读更多...
涨点技巧：注意力机制---Yolov8引入Resnet_CBAM，CBAM升级版

涨点技巧：注意力机制---Yolov8引入Resnet_CBAM，CBAM升级版

1.计算机视觉中的注意力机制 一般来说，注意力机制通常被分为以下基本四大类： 通道注意力 Channel Attention 空间注意力机制 Spatial Attention 时间注意力机制 Temporal Attention 分支注意力机制 Branch Attention 1.1.CBAM：通道注意力和空间注意力的集成者 轻量级…
阅读更多...
版本控制系统有哪些推荐？ - 易智编译EaseEditing

版本控制系统有哪些推荐？ - 易智编译EaseEditing

以下是几个常用的版本控制系统&#xff08;Version Control System&#xff09;推荐&#xff0c;并对它们进行简单介绍&#xff1a; Git&#xff1a; Git是目前最流行的分布式版本控制系统。它具有高效、灵活和强大的功能&#xff0c;支持快速的代码提交、分支管理、合并操作…
阅读更多...
高频面试八股文原理篇(五)索引相关

高频面试八股文原理篇(五)索引相关

目录 索引的优缺点 MySQL索引类型 索引原理 常见索引类型 MySQL数据库要⽤B树存储索引⽽不⽤红⿊树、B树、 Hash的原因 怎么验证 MySQL 的索引是否满足需求 聚簇索引和非聚簇索引 索引的优缺点 索引的优点 可以大大加快数据的检索速度&#xff0c;这也是创建索引的最主…
阅读更多...
蚂蚁Ant Design组件库的免费在线资源

蚂蚁Ant Design组件库的免费在线资源

Ant Design&#xff08;蚂蚁组件&#xff09;是蚂蚁集团体验技术部经过大量项目实践和总结&#xff0c;逐步打磨出的一个设计系统&#xff0c;内含带有 React 的 UI 库。它是为企业级产品设计而创建的。Ant Design 提供了高质量的交互界面设计组件和演示。作为 UI 设计师&#…
阅读更多...
Spring：Spring框架结构 ②

Spring：Spring框架结构 ②

一、结构体现的价值 1、可读性强。 2、可维护性。 3、优秀的框架均具有分而治之的思想。清晰的设计、合理的归类、模块化是走向优秀框架的基础性武器。 二、Spring框架的模块划分 1、整体轮廓 Spring框架包含的功能大约由20个小模块组成。这些模块按组可分为核心容器(Core Co…
阅读更多...
独立、相关、正交

独立、相关、正交

文章目录 【1. 独立】【2. 相关】【3.正交】【4. 相互关系】相关和独立相关和正交独立和正交独立、不相关和正交小结 【5. 参考文献】 【1. 独立】 独立&#xff1a;对于两个随机变量 y 1 y_1 y1​ 和 y 2 y_2 y2​&#xff0c;若 y 1 y_1 y1​ 的有关信息不给出 y 2 y_2 …
阅读更多...
基于AT89C52单片机的无线温度监测设计

基于AT89C52单片机的无线温度监测设计

点击链接获取Keil源码与Project Backups仿真图&#xff1a; https://download.csdn.net/download/qq_64505944/87848530?spm1001.2014.3001.5503 源码获取 主要内容&#xff1a; 设计一个温度监测器&#xff0c;温度异常时警报器能够响起&#xff0c;设定初始温度&#xff0…
阅读更多...
0基础学习VR全景平台篇第33章：场景功能-嵌入标尺

0基础学习VR全景平台篇第33章：场景功能-嵌入标尺

功能位置示意 一、本功能将用在哪里&#xff1f; 嵌入功能可对VR全景作品嵌入【图片】【视频】【文字】【标尺】四种不同类型内容&#xff1b; 本次主要带来标尺类型的介绍&#xff0c;可对VR全景作品中&#xff0c;位置信息较多的场景进行标注&#xff0c;在单场景中植入更多…
阅读更多...
R-Meta分析与【文献计量分析、贝叶斯、机器学习等】多技术融合实践

R-Meta分析与【文献计量分析、贝叶斯、机器学习等】多技术融合实践

Meta分析是针对某一科研问题&#xff0c;根据明确的搜索策略、选择筛选文献标准、采用严格的评价方法&#xff0c;对来源不同的研究成果进行收集、合并及定量统计分析的方法&#xff0c;最早出现于“循证医学”&#xff0c;现已广泛应用于农林生态&#xff0c;资源环境等方面。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023