二叉树简单实现（C语言版）

一.简单建二叉树

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二 叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树 操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。
所以我们先简单建一个二叉树：
以该二叉树为例： 
//法一
TreeNode* Creat()
{//开辟树的空间TreeNode* node1 = (TreeNode*)malloc(sizeof(TreeNode));assert(node1);TreeNode* node2 = (TreeNode*)malloc(sizeof(TreeNode));assert(node2);TreeNode* node3 = (TreeNode*)malloc(sizeof(TreeNode));assert(node3);TreeNode* node4 = (TreeNode*)malloc(sizeof(TreeNode));assert(node4);TreeNode* node5 = (TreeNode*)malloc(sizeof(TreeNode));assert(node5);TreeNode* node6 = (TreeNode*)malloc(sizeof(TreeNode));assert(node6);//确定指向node1->left = node2;node1->right = node4;node2->left = node3;node4->left = node5;node4->right = node6;//对每个进行赋值node1->date = 1;node2->date = 2;node3->date = 3;node4->date = 4;node5->date = 5;node6->date = 6;return node1;}

但是你会发现，这是一个明显可以简化的代码

简化结果如下：

//法二
TreeNode* BuyTreeNode(int x)
{//开辟树的空间TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));assert(node);node->date = x;node->left = NULL;node->right = NULL;return node;
}
TreeNode* Creat()
{//开辟树并且对每个进行赋值TreeNode* node1 = BuyTreeNode(1);TreeNode* node2 = BuyTreeNode(2);TreeNode* node3 = BuyTreeNode(3);TreeNode* node4 = BuyTreeNode(4);TreeNode* node5 = BuyTreeNode(5);TreeNode* node6 = BuyTreeNode(6);//确定指向node1->left = node2;node1->right = node4;node2->left = node3;node4->left = node5;node4->right = node6;return node1;}

由于学习要逐渐深入，所以我们先简单构建二叉树。

二.二叉树的遍历

二叉树的概念：
二叉树是：
1. 空树
2. 非空：根节点，根节点的左子树、根节点的右子树组成的
你会发现：
二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。
回到我们的主题上：
二叉树主要分为四种遍历：

2.1.前序遍历

定义：

前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前
即：先根-》左子树-》右子树
回到我们前面的例题，如果该树是前序遍历，请问结果是什么？
注意：无写成NULL形式
结果为： 1->2->3->NULL->NULL->NULL->4->5->NULL->NULL->6->NULL->NULL
初学时一定不要省略了NULL，这有助于我们理解
下面我们用代码实现前序： 
// 二叉树前序遍历
void PrevOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");return;}else{printf("%d ", root->date);PrevOrder(root->left);PrevOrder(root->right);}
}

结合前面我们建的二叉树，输出结果：

//法二
TreeNode* BuyTreeNode(int x)
{//开辟树的空间TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));assert(node);node->date = x;node->left = NULL;node->right = NULL;return node;
}
TreeNode* CreateTree()
{//开辟树并且对每个进行赋值TreeNode* node1 = BuyTreeNode(1);TreeNode* node2 = BuyTreeNode(2);TreeNode* node3 = BuyTreeNode(3);TreeNode* node4 = BuyTreeNode(4);TreeNode* node5 = BuyTreeNode(5);TreeNode* node6 = BuyTreeNode(6);//确定指向node1->left = node2;node1->right = node4;node2->left = node3;node4->left = node5;node4->right = node6;return node1;
}
//
// 二叉树前序遍历
void PrevOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");return;}else{printf("%d ", root->date);PrevOrder(root->left);PrevOrder(root->right);}
}
int main()
{TreeNode* root = CreateTree();PrevOrder(root);return 0;
}

2.2.中序遍历

定义：

中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。

即：左子树-》树根-》右子树

同上，回到上面题目：

结果：NULL->3->NULL->2->NULL->1->NULL->5->NULL->4->NULL->6->NULL

代码如下：

// 二叉树中序遍历
void InOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");}else{InOrder(root->left);printf("%d ", root->date);InOrder(root->right);}
}

还是检验下：

TreeNode* BuyTreeNode(int x)
{//开辟树的空间TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));assert(node);node->date = x;node->left = NULL;node->right = NULL;return node;
}
TreeNode* CreateTree()
{//开辟树并且对每个进行赋值TreeNode* node1 = BuyTreeNode(1);TreeNode* node2 = BuyTreeNode(2);TreeNode* node3 = BuyTreeNode(3);TreeNode* node4 = BuyTreeNode(4);TreeNode* node5 = BuyTreeNode(5);TreeNode* node6 = BuyTreeNode(6);//确定指向node1->left = node2;node1->right = node4;node2->left = node3;node4->left = node5;node4->right = node6;return node1;
}
// 二叉树中序遍历
void InOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");}else{InOrder(root->left);printf("%d ", root->date);InOrder(root->right);}
}
int main()
{TreeNode* root = CreateTree();InOrder(root);printf("\n");return 0;
}

2.3.后序遍历

定义：

后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后

即：左子树-》右子树-》树根

上面的树结果：NULL->NULL->3->NULL->2->NULL->NULL->5->NULL->NULL->6->4->1

代码如下：

// 二叉树后序遍历
void PostOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");}else{PostOrder(root->left);PostOrder(root->right);printf("%d ", root->date);		}
}

验证：

TreeNode* BuyTreeNode(int x)
{//开辟树的空间TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));assert(node);node->date = x;node->left = NULL;node->right = NULL;return node;
}
TreeNode* CreateTree()
{//开辟树并且对每个进行赋值TreeNode* node1 = BuyTreeNode(1);TreeNode* node2 = BuyTreeNode(2);TreeNode* node3 = BuyTreeNode(3);TreeNode* node4 = BuyTreeNode(4);TreeNode* node5 = BuyTreeNode(5);TreeNode* node6 = BuyTreeNode(6);//确定指向node1->left = node2;node1->right = node4;node2->left = node3;node4->left = node5;node4->right = node6;return node1;
}
// 二叉树后序遍历
void PostOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");}else{PostOrder(root->left);PostOrder(root->right);printf("%d ", root->date);		}
}
int main()
{TreeNode* root = CreateTree();PostOrder(root);printf("\n");return 0;
}

2.4.层序遍历

层序遍历 ：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1 ，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第 2 层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历
后面我们会讲（下一个文章）

三.实现二叉树接口

3.1二叉树节点个数

还是对于这个二叉树，请用递归实现求它的节点个数
你想到了吗？如果没有，请看看我的实现吧！
对于这棵树，是不是可以看成左子树+右子树+树根，也就是左子树+右子树+1，左子树是不是也可以继续看成左子树+右子树+树根，即左子树+右子树+1，右子树同理，所以我们因此就实现了递归
看代码： 
// 二叉树节点个数
int BinaryTreeSize(TreeNode* root)
{if (root == NULL){return 0;}else{return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;}
}

有煤油恍然大悟的感觉！

检验：

int main()
{TreeNode* root = CreateTree();int ret = BinaryTreeSize(root);printf("%d\n", ret);return 0;
}

（我省略了建树的代码，需要可以去前面找，后面我都会适当省略）

结果

3.2.二叉树叶子节点个数

(后面都是这棵树）
对于这个二叉树，请用 递归实现求它的 二叉树叶子节点个数
我这里就直接写了，当然你可以思考之后再看下面的代码。
要解决这个问题，关键是在于要知道什么是叶子节点，是不是它的左右子叶都是NULL，那么递归是不是就好理解了，如果为NULL，0个叶，如果左右子叶都是NULL，它为子叶
看代码： 
// 二叉树叶子节点个数
int BinaryTreeLeafSize(TreeNode* root)
{if (root == NULL){return 0;}else if ((root->left == NULL) && (root->right == NULL)){return 1;}return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

验证：

int main()
{TreeNode* root = CreateTree();int ret2=BinaryTreeLeafSize(root);printf("%d\n", ret2);return 0;
}


3.3.二叉树的高度

也可以认为是深度
还是递归法。
是不是树高度=max（左子树，右子树）+1；左子树高度=max（左子树，右子树），右子树同理。
代码如下： 
//法一
//二叉树的高度
int BinaryTreeHeight(TreeNode* root)
{if (root == NULL){return 0;}else{int left = BinaryTreeHeight(root->left);int right = BinaryTreeHeight(root->right);return fmax(left, right) + 1;}
}
//法二
//二叉树的高度
int BinaryTreeHeight(TreeNode* root)
{if (root == NULL){return 0;}else{return fmax(BinaryTreeHeight(root->left), BinaryTreeHeight(root->right)) + 1;}
}

验证：

int main()
{TreeNode* root = CreateTree();int ret3 = BinaryTreeHeight(root);printf("%d\n", ret3);return 0;
}

3.4.二叉树第k层节点个数

求第K层节点个数，这是不是也是一个递归的题目，当K==1时，是不是就是一个节点，当k>1时，是不是可以依次递减。

代码实现过程：

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(TreeNode* root, int k)
{if (root == NULL){return 0;}if (k == 1){return 1;}else{return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);}
}
检验： 
int main()
{TreeNode* root = CreateTree();int ret4=BinaryTreeLevelKSize(root, 2);printf("%d", ret4);int ret5 = BinaryTreeLevelKSize(root, 3);printf("%d", ret5);return 0;
}

3.5.二叉树查找值为x的节点

对于查找用递归来写，我们还是可以按照之前的方法，用分治法来解决。
情况一：root==NULL时，是不是该返回NULL
情况二：不为空，root本身为结果
相当于找自身，不行的话就找左子树和右子树
难点是找到之后如何将地址返回到开始的位置
是不是我们可以提前保存一下；找到返回保存值，依次回溯该值即可。
下面我们实现它： 
//法一
// 二叉树查找值为x的节点定义
TreeNode* BinaryTreeFind(TreeNode* root, BTDateType x)
{if (root == NULL){return NULL;}if (root->date == x){return root;}TreeNode* ret1 = BinaryTreeFind(root->left, x);if (ret1 != NULL){return ret1;}TreeNode* ret2 = BinaryTreeFind(root->right, x);if (ret2 != NULL){return ret2;}return NULL;
}

检查：

int main()
{TreeNode* root = CreateTree();PrevOrder(root);printf("\n");TreeNode* ps = BinaryTreeFind(root, 4);if (ps == NULL){printf("没找到\n");}else{ps->date = 5;PrevOrder(root);printf("\n");}return 0;
}

如果找到的话结果4会变成5，看结果：

没问题，下面我们来用第二种方法实现： 
//法二
TreeNode* BinaryTreeFind(TreeNode* root, BTDateType x)
{if (root == NULL){return NULL;}if (root->date == x){return root;}TreeNode* ret1 = BinaryTreeFind(root->left, x);if (ret1 != NULL){return ret1;}return BinaryTreeFind(root->right, x);;
}

结果没问题，大家可以深入理解下。
你是否发现这只是前序查找顺序，但是实际中，不一定就是前序查找，你是否会写中序，后序呢？

3.6.通过前序遍历的数组构建二叉树

这个是扩展知识，大家可以了解如何真正建树。 
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
TreeNode* BinaryTreeCreate(char* arr, int* pi)//注意：char
{if (arr[(*pi)] == '#'){(*pi)++;return NULL;}TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));//判断开辟情况if (root == NULL){perror(root);exit(-1);}		root->date = arr[(*pi)++];root->left = BinaryTreeCreate(arr, pi);root->right = BinaryTreeCreate(arr, pi);return root;
}

3.7.二叉树销毁

任何程序都要在不使用时进行销毁，所以我们下面来实现销毁接口。

// 二叉树销毁(一级指针法）//需要外面手动置空
void BinaryTreeDestory1(TreeNode* root)
{if (root == NULL)return;//后序销毁法BinaryTreeDestory1(root->left);BinaryTreeDestory1(root->right);free(root);
}
// 二叉树销毁(二级指针法）//不需要外面手动置空
void BinaryTreeDestory2(TreeNode** root)
{if (root == NULL)return;//后序销毁法BinaryTreeDestory2((*root)->left);BinaryTreeDestory2((*root)->right);free(root);root = NULL;
}
最后，我们所有汇总一下全部文件：
BinaryTreeNode.h： 
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
//定义结构体
typedef int BTDateType;
typedef struct BinaryTreeNode
{BTDateType date;struct BinaryTreeNode* left;struct BinaryTreeNode* right;
}TreeNode;
//动态开辟空间声明
TreeNode* BuyTreeNode(int x);
//建立二叉树声明
TreeNode* CreateTree();
// 二叉树前序遍历声明
void PrevOrder(TreeNode* root);
// 二叉树中序遍历声明
void InOrder(TreeNode* root);
// 二叉树后序遍历声明
void PostOrder(TreeNode* root);
// 二叉树节点个数声明
int BinaryTreeSize(TreeNode* root);
// 二叉树叶子节点个数声明
int BinaryTreeLeafSize(TreeNode* root);
//二叉树的高度声明
int BinaryTreeHeight(TreeNode* root);
// 二叉树第k层节点个数声明
int BinaryTreeLevelKSize(TreeNode* root, int k);
// 二叉树查找值为x的节点声明（前序）
TreeNode* BinaryTreeFindPreamble(TreeNode* root, BTDateType x);
//二叉树查找值为x的节点声明（中序）
TreeNode* BinaryTreeFindmedium(TreeNode* root, BTDateType x);
//二叉树查找值为x的节点声明（后序）
TreeNode* BinaryTreeFindpostorder(TreeNode* root, BTDateType x);

BinaryTreeNode.c：

#include "BinaryTreeNode.h"
//法一
//TreeNode* Creat()
//{
//	//开辟树的空间
//	TreeNode* node1 = (TreeNode*)malloc(sizeof(TreeNode));
//	assert(node1);
//	TreeNode* node2 = (TreeNode*)malloc(sizeof(TreeNode));
//	assert(node2);
//	TreeNode* node3 = (TreeNode*)malloc(sizeof(TreeNode));
//	assert(node3);
//	TreeNode* node4 = (TreeNode*)malloc(sizeof(TreeNode));
//	assert(node4);
//	TreeNode* node5 = (TreeNode*)malloc(sizeof(TreeNode));
//	assert(node5);
//	TreeNode* node6 = (TreeNode*)malloc(sizeof(TreeNode));
//	assert(node6);
//
//	//确定指向
//	node1->left = node2;
//	node1->right = node4;
//	node2->left = node3;
//	node4->left = node5;
//	node4->right = node6;
//
//	//对每个进行赋值
//	node1->date = 1;
//	node2->date = 2;
//	node3->date = 3;
//	node4->date = 4;
//	node5->date = 5;
//	node6->date = 6;
//}
//法二
//动态开辟空间定义
TreeNode* BuyTreeNode(int x)
{//开辟树的空间TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));assert(node);node->date = x;node->left = NULL;node->right = NULL;return node;
}
//建立二叉树定义
TreeNode* CreateTree()
{//开辟树并且对每个进行赋值TreeNode* node1 = BuyTreeNode(1);TreeNode* node2 = BuyTreeNode(2);TreeNode* node3 = BuyTreeNode(3);TreeNode* node4 = BuyTreeNode(4);TreeNode* node5 = BuyTreeNode(5);TreeNode* node6 = BuyTreeNode(6);//确定指向node1->left = node2;node1->right = node4;node2->left = node3;node4->left = node5;node4->right = node6;return node1;
}
// 二叉树前序遍历定义
void PrevOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");return;}else{printf("%d ", root->date);PrevOrder(root->left);PrevOrder(root->right);}
}
// 二叉树中序遍历定义
void InOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");}else{InOrder(root->left);printf("%d ", root->date);InOrder(root->right);}
}
// 二叉树后序遍历定义
void PostOrder(TreeNode* root)
{if (root == NULL){printf("NULL ");}else{PostOrder(root->left);PostOrder(root->right);printf("%d ", root->date);		}
}
// 层序遍历定义(一：一起遍历）
void LevelOrder(TreeNode* root)
{;}
// 二叉树节点个数定义
int BinaryTreeSize(TreeNode* root)
{if (root == NULL){return 0;}else{return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;}
}
// 二叉树叶子节点个数定义
int BinaryTreeLeafSize(TreeNode* root)
{if (root == NULL){return 0;}else if ((root->left == NULL) && (root->right == NULL)){return 1;}return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}
法一
二叉树的高度定义
//int BinaryTreeHeight(TreeNode* root)
//{
//	if (root == NULL)
//	{
//		return 0;
//	}
//	else
//	{
//		int left = BinaryTreeHeight(root->left);
//		int right = BinaryTreeHeight(root->right);
//		return fmax(left, right) + 1;
//	}
//}
//法二
//二叉树的高度定义
int BinaryTreeHeight(TreeNode* root)
{if (root == NULL){return 0;}else{return fmax(BinaryTreeHeight(root->left), BinaryTreeHeight(root->right)) + 1;}
}
// 二叉树第k层节点个数定义
int BinaryTreeLevelKSize(TreeNode* root, int k)
{if (root == NULL){return 0;}if (k == 1){return 1;}else{return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);}
}
//法一
// 二叉树查找值为x的节点定义
//TreeNode* BinaryTreeFind(TreeNode* root, BTDateType x)
//{
//	if (root == NULL)
//	{
//		return NULL;
//	}
//	if (root->date == x)
//	{
//		return root;
//	}
//	TreeNode* ret1 = BinaryTreeFind(root->left, x);
//	if (ret1 != NULL)
//	{
//		return ret1;
//	}
//	TreeNode* ret2 = BinaryTreeFind(root->right, x);
//	if (ret2 != NULL)
//	{
//		return ret2;
//	}
//	return NULL;
//}
//法二
TreeNode* BinaryTreeFindPreamble(TreeNode* root, BTDateType x)
{if (root == NULL){return NULL;}if (root->date == x){return root;}TreeNode* ret1 = BinaryTreeFindPreamble(root->left, x);if (ret1 != NULL){return ret1;}return BinaryTreeFindPreamble(root->right, x);;
}
//二叉树查找值为x的节点定义(中序）
TreeNode* BinaryTreeFindmedium(TreeNode* root, BTDateType x)
{if (root == NULL){return NULL;}TreeNode* ret1 = BinaryTreeFindmedium(root->left, x);if (ret1 != NULL){return ret1;}if (root->date == x){return root;}TreeNode* ret2 = BinaryTreeFindmedium(root->right, x);if (ret2 != NULL){return ret2;}return NULL;
}
//二叉树查找值为x的节点定义（后序）
TreeNode* BinaryTreeFindpostorder(TreeNode* root, BTDateType x)
{if (root == NULL){return NULL;}TreeNode* ret1 = BinaryTreeFindpostorder(root->left, x);if (ret1 != NULL){return ret1;}TreeNode* ret2 = BinaryTreeFindpostorder(root->right, x);if (ret2 != NULL){return ret2;}if (root->date == x){return root;}return NULL;
}
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
TreeNode* BinaryTreeCreate(char* arr, int* pi)//注意：char
{if (arr[(*pi)] == '#'){(*pi)++;return NULL;}TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));//判断开辟情况if (root == NULL){perror(root);exit(-1);}		root->date = arr[(*pi)++];root->left = BinaryTreeCreate(arr, pi);root->right = BinaryTreeCreate(arr, pi);return root;
}
// 二叉树销毁(一级指针法）//需要外面手动置空
void BinaryTreeDestory1(TreeNode* root)
{if (root == NULL)return;//后序销毁法BinaryTreeDestory1(root->left);BinaryTreeDestory1(root->right);free(root);
}
// 二叉树销毁(二级指针法）//不需要外面手动置空
void BinaryTreeDestory2(TreeNode** root)
{if (root == NULL)return;//后序销毁法BinaryTreeDestory2((*root)->left);BinaryTreeDestory2((*root)->right);free(root);root = NULL;
}

三.关于树的基本部分就到这了，感谢大家的支持！！！
祝福大家元旦假期快乐。

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

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

相关文章

SQL注入【ByPass有点难的靶场实战】(九)

SQL注入【ByPass有点难的靶场实战】(九)

★★免责声明★★ 文章中涉及的程序(方法)可能带有攻击性&#xff0c;仅供安全研究与学习之用&#xff0c;读者将信息做其他用途&#xff0c;由Ta承担全部法律及连带责任&#xff0c;文章作者不承担任何法律及连带责任。 0、总体思路 先确认是否可以SQL注入&#xff0c;使用单…
阅读更多...
2023年03月20日_对李开复3月20日线下媒体会的解读

2023年03月20日_对李开复3月20日线下媒体会的解读

最近这个AI大模型 因为GPT4.0 ChatGPT 文心一言等等这些事情呢 一下子就被推到了风口浪尖 我们也做了来介绍相关的进展 国内呢也不断有一些大佬开始下场 包括王慧文、张朝阳、李彦宏什么的 都开始说自己要搞AI大模型 就在昨天呢 创新工厂的董事长兼CEO李开复 也发朋友…
阅读更多...
2022年全球运维大会（GOPS深圳站）-核心PPT资料下载

2022年全球运维大会（GOPS深圳站）-核心PPT资料下载

一、峰会简介 GOPS 主要面向运维行业的中高端技术人员&#xff0c;包括运维、开发、测试、架构师等群体。目的在于帮助IT技术从业者系统学习了解相关知识体系&#xff0c;让创新技术推动社会进步。您将会看到国内外知名企业的相关技术案例&#xff0c;也能与国内顶尖的技术专家…
阅读更多...
【C++】STL 容器 - set 集合容器 ⑦ ( 查找元素 - set#find 函数 | 获取元素个数 - set#count 函数 )

【C++】STL 容器 - set 集合容器 ⑦ ( 查找元素 - set#find 函数 | 获取元素个数 - set#count 函数 )

文章目录 一、查找元素 - set#find 函数1、函数原型 简介2、代码示例 - set#find 函数 二、获取元素个数 - set#count 函数1、函数原型 简介2、代码示例 - set#find 函数 一、查找元素 - set#find 函数 1、函数原型 简介 在 C 语言的 STL 标准模板库 , std::set 集合容器 是一个…
阅读更多...
HCIP：rip综合实验

HCIP：rip综合实验

实验要求&#xff1a; 【R1-R2-R3-R4-R5运行RIPV2】 【R6-R7运行RIPV1】 1.使用合理IP地址规划网络&#xff0c;各自创建环回接口 2.R1创建环回 172.16.1.1/24 172.16.2.1/24 172.16.3.1/24 3.要求R3使用R2访问R1环回 4.加快网络收敛&#xff0c;减少路由条目数量&#xff0c;增…
阅读更多...
2024年【R1快开门式压力容器操作】试题及解析及R1快开门式压力容器操作复审考试

2024年【R1快开门式压力容器操作】试题及解析及R1快开门式压力容器操作复审考试

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 R1快开门式压力容器操作试题及解析根据新R1快开门式压力容器操作考试大纲要求&#xff0c;安全生产模拟考试一点通将R1快开门式压力容器操作模拟考试试题进行汇编&#xff0c;组成一套R1快开门式压力容器操作全真模拟…
阅读更多...
RHCE9学习指南 第12章 ssh远程登录系统和远程拷贝

RHCE9学习指南 第12章 ssh远程登录系统和远程拷贝

很多时候服务器并没有显示器&#xff0c;我们也不可能每次都通过控制台去管理服务器&#xff0c;这时就需要远程登录。远程登录到服务器可以通过Telnet或ssh的方式。但是用Telnet登录&#xff0c;整个过程都是以明文的方式传输的&#xff0c;不安全。所以&#xff0c;建议使用s…
阅读更多...
Java基础语法(注释,关键字,字面量,变量,数据类型,标识符,键盘录入,IDEA安装,类,模块,项目)

Java基础语法(注释,关键字,字面量,变量,数据类型,标识符,键盘录入,IDEA安装,类,模块,项目)

文章目录 day02 - Java基础语法1. 注释使用的技巧注意点 2. 关键字2.1 概念2.2 第一个关键字class 3. 字面量区分技巧 4. 变量4.1 什么是变量&#xff1f;4.2 变量的定义格式4.2.1 格式详解4.2.2 常用的数据类型4.2.3 变量的注意事项 4.3 变量的练习 5. 数据类型5.1 Java语言数…
阅读更多...
Vue3-30-路由-嵌套路由的基本使用

Vue3-30-路由-嵌套路由的基本使用

什么是嵌套路由 嵌套路由 &#xff1a;就是一个组件内部还希望展示其他的组件&#xff0c;使用嵌套的方式实现页面组件的渲染。 就像 根组件 通过路由渲染 普通组件一样&#xff0c;嵌套路由也是一样的道理。 嵌套路由的相关关键配置 1、<router-view> 标签 声明 被嵌套组…
阅读更多...
MendelianRandomization | 孟德尔随机化神包更新啦！~（一）（小试牛刀）

MendelianRandomization | 孟德尔随机化神包更新啦！~（一）（小试牛刀）

1写在前面 今天发现MendelianRandomization包更新v0.9了。&#x1f61c; 其实也算不上更新。&#x1fae0; 跟大家一起分享一下这个包做MR的用法吧。&#x1f929; 还有一个包就是TwoSampleMR&#xff0c;大家有兴趣可以去学一下。&#x1f605; 2用到的包 rm(list ls())# ins…
阅读更多...
探索效率与可扩展性：MinIO图片服 VS FastDFS图片服

探索效率与可扩展性：MinIO图片服 VS FastDFS图片服

目录 1、前言 2、背景知识 2.1 Minio图片服的概述 2.2 FastDFS图片服的概述 3、性能比较 3.1 存储性能比较 3.1.1 对比上传速度和下载速度 3.1.2 比较两者的读写性能 3.2 负载均衡性能比较 4、可扩展性比较 4.1 横向扩展性性能比较 4.2 纵向扩展性性能比较 5、结语…
阅读更多...
CCNP课程实验-Route_Path_Control_CFG

CCNP课程实验-Route_Path_Control_CFG

目录 实验条件网络拓朴需求 配置实现基础配置需求实现1.A---F所有区用Loopback模拟&#xff0c;地址格式为&#xff1a;XX.XX.XX.XX/32&#xff0c;其中X为路由器编号。根据拓扑宣告进对应协议。A1和A2区为特例&#xff0c;A1&#xff1a;55.55.55.0/24&#xff0c;A2&#xff…
阅读更多...
ArkTS基本概念装饰器

ArkTS基本概念装饰器

目录 ArkTS基本概念 装饰器汇总 ArkTS基本概念 ArkTS是HarmonyOS的主力应用开发语言。 它在TypeScript&#xff08;简称TS&#xff09;的基础上&#xff0c;匹配ArkUI框架&#xff0c;扩展了声明式UI、状态管理等相应的能力&#xff0c;让开发者以更简洁、更自然的方式开发跨…
阅读更多...
Python变量与常量

Python变量与常量

第三章、变量与常量 一、标识符 1、定义 在 Python 中&#xff0c;标识符是用来标识变量、函数、类、模块或其他用户定义的对象的名称。标识符是程序员自定义的名称&#xff0c;用于在代码中标识不同的实体&#xff0c;使得代码可读性更强&#xff0c;更易于理解和维护。标识…
阅读更多...
汽配订货系统 助力汽配行业数字化转型升级

汽配订货系统 助力汽配行业数字化转型升级

一个汽配订货系统可以助力汽配行业数字化转型升级&#xff0c;提供以下功能和优势&#xff1a; 1. 订单管理&#xff1a;订货系统可以记录每笔订单的详细信息&#xff0c;包括客户信息、产品信息、价格、数量等&#xff0c;方便汽配商进行订单统计和分析。 2. 库存管理&#x…
阅读更多...
mxxWechatBot微信机器人V2版本文档说明

mxxWechatBot微信机器人V2版本文档说明

大家伙&#xff0c;我是雄雄&#xff0c;欢迎关注微信公众号&#xff1a;雄雄的小课堂。 先看这里 一、前言二、mxxWechatBot流程图三、怎么使用&#xff1f; 一、前言 经过不断地探索与研究&#xff0c;mxxWechatBot正式上线&#xff0c;届时全面开放使用。 mxxWechatBot&am…
阅读更多...
59. 螺旋矩阵 II

59. 螺旋矩阵 II

给你一个正整数 n &#xff0c;生成一个包含 1 到 n2 所有元素&#xff0c;且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。 示例 1&#xff1a; 输入&#xff1a;n 3 输出&#xff1a;[[1,2,3],[8,9,4],[7,6,5]]示例 2&#xff1a; 输入&#xff1a;n 1 输出&…
阅读更多...
OSPF的DR与BDR-新版（16）

OSPF的DR与BDR-新版（16）

目录 整体拓扑 操作步骤 1.基本配置 1.1 配置R1的IP 1.2 配置R2的IP 1.3 配置R3的IP 1.4 配置R4的IP 1.5 检测R1与R4连通性 1.6 检测R1与R2连通性 1.7 检测R1与R3连通性 2.搭建基本的OSPF网络 2.1 配置R1 OSPF 2.2 配置R2 OSPF 2.3 配置R3 OSPF 2.4 配置R4 OSPF…
阅读更多...
前端常用的实用工具与网站

前端常用的实用工具与网站

1. Snipaste–截图工具 Snipaste截图软件应该算是前端必备的截图软件了&#xff0c;之前也用过其他很多截图软件&#xff0c;这个算最为方便的了。而且最重要的时&#xff0c;它可以回滚截图历史&#xff0c;并且在回滚中还能截图。下面是官网地址的网站链接&#xff0c;当然我…
阅读更多...
Unity坦克大战开发全流程——开始场景——设置界面

Unity坦克大战开发全流程——开始场景——设置界面

开始场景——设置界面 step1&#xff1a;设置面板的背景图 照着这个来设置就行了 step2&#xff1a;写代码 关联的按钮控件 监听事件函数 注意&#xff1a;要在start函数中再写一行HideMe函数&#xff0c;以便该面板能在一开始就能隐藏自己。 再在BeginPanel脚本中调用该函数即…
阅读更多...
最新文章

Copyright @ 2022~2023