数据结构上机实验——二叉树的实现、二叉树遍历、求二叉树的深度/节点数目/叶节点数目、计算二叉树度为1或2的节点数、判断二叉树是否相似

news2024/11/25 18:37:47

文章目录

  • 数据结构上机实验
    • 1.要求
    • 2.二叉树的实现
      • 2.1创建一颗二叉树
      • 2.2对这棵二叉树进行遍历
      • 2.3求二叉树的深度/节点数目/叶节点数目
      • 2.4计算二叉树中度为 1 或 2 的结点数
      • 2.5判断2棵二叉树是否相似，若相似返回1，否则返回0
    • 3.全部源码
      • 测试：
      • BinaryTree.h
      • test.cpp

数据结构上机实验

1.要求

   建立一棵二叉树，试编程实现二叉树的如下基本操作。
   1.创建一棵一棵二叉算法。
   2.对这棵二叉树进行遍历：先序或中序或后序，分别输出结点的遍历序列。
   3.求二叉树的深度/节点数目/叶节点数目。（选做一个）
   4.计算二叉树中度为1 的结点数；
   5.计算二叉树中度为2 的结点数。
   6.判断2棵二叉树是否相似，若相似返回1，否则返回0

            

2.二叉树的实现

  二叉树的介绍
在这里插入图片描述
  

2.1创建一颗二叉树

  我们现在可以简单实现一个二叉树的结构，其中包括一个二叉树节点（BNode）和一个二叉树（BTree）类。

  我们定义了一个名为BNode的结构体，它代表二叉树的节点。每个节点包含一个数据元素（data，其类型为int）和两个指向其左右子节点的指针（left和right）。

  然后定义了一个名为BTree的类，它包含一个私有成员变量_root，这是一个指向BNode的指针。这个指针表示了树的根节点。这个类还包含一个默认的构造函数，该构造函数将_root初始化为nullptr，即没有初始的根节点。

#define BTDataType int

//定义二叉树节点
typedef struct BTreeNode
{
	BTDataType data;
	struct BTreeNode* left;
	struct BTreeNode* right;
}BNode;

//定义二叉树
class BTree
{
public:
	//构造函数
	BTree()
	{
		_root = nullptr;
	}
	
private:
	BNode* _root;
};

  
输入字符递归创建二叉树：
  我们先使用引用接受一个 BNode*类型的参数 root。这样我们就可以在函数内部，直接对 root 进行操作，最后返回给tmp，再赋给_root。

  这个函数首先从标准输入读取一个字符 val。如果 val 是 . ，则 root 被设置为 nullptr，表示该节点为空。如果 val 不是 .，则创建一个新的 BNode 对象，其 data 成员的值为 val 减去字符 ‘0’ 的 ASCII 值（这样可以获得一个整数），然后递归地创建这个新节点的左子树和右子树。最后，_BTCreate 返回，控制权回到调用该函数的代码。

//递归创建二叉树
void _BTCreate(BNode*& root)
{
	char val;
	cin >> val;
	if (val == '.') root = nullptr;
	else
	{
		root = new BNode(val - '0');
		_BTCreate(root->left);
		_BTCreate(root->right);
	}
}

//递归创建二叉树
void BTCreate()
{
	BNode* tmp;
	_BTCreate(tmp);
	_root = tmp;
}

  

2.2对这棵二叉树进行遍历

在这里插入图片描述

前序遍历：

  我们创建_PreOrder(BNode* root)这个函数是用来前序遍历。它的顺序是：先访问根节点，然后访问左子树，最后访问右子树。

  如果 root 是 nullptr（即当前节点为空），它将输出 “NULL” 并返回。如果 root 非空，它会输出当前节点的数据（root->data），然后递归地对左子树和右子树进行前序遍历。

  由于二叉树的前序遍历是一个递归算法，为了可以将根节点不断的更新，并且递归。 我们需要封装一下，对于后面需要递归的函数，我们都需要将根节点作为参数，进行递归操作。

//前序遍历
void _PreOrder(BNode* root)
{
	if (root == nullptr)
	{
		cout << "NULL" << " ";
		return;
	}

	cout << root->data << " ";
	_PreOrder(root->left);
	_PreOrder(root->right);
}

//前序遍历
void PreOrder()
{
	_PreOrder(_root);
	cout << endl;
}

  
中序遍历：

  我们创建 _InOrder(BNode* root) 来进行中序遍历，它的顺序是：先访问左子树，然后访问根节点，最后访问右子树。

  如果 root 是 nullptr，表示当前节点为空，输出 “NULL” 并返回。如果 root 非空，先递归地遍历左子树，然后输出当前节点的数据 root->data，最后递归地遍历右子树。

//中序遍历
void _InOrder(BNode* root)
{
	if (root == nullptr)
	{
		cout << "NULL" << " ";
		return;
	}

	_InOrder(root->left);
	cout << root->data << " ";
	_InOrder(root->right);
}

//中序遍历
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

  
后序遍历：

  我们创建 _PostOrder(BNode* root) 函数来进行进行后序遍历，它的顺序是：先访问左子树，然后访问右子树，最后访问根节点。

  如果 root 是 nullptr，表示当前节点为空，输出 “NULL” 并返回。如果 root 非空，先递归地遍历左子树，然后递归地遍历右子树，最后输出当前节点的数据 root->data。

//后序遍历
void _PostOrder(BNode* root)
{
	if (root == nullptr)
	{
		cout << "NULL" << " ";
		return;
	}

	_PostOrder(root->left);
	_PostOrder(root->right);
	cout << root->data << " ";
}

//后序遍历
void PostOrder()
{
	_PostOrder(_root);
	cout<<endl;
}

  

2.3求二叉树的深度/节点数目/叶节点数目

计算二叉树深度：

  我们使用递归的方式来实现计算二叉树的深度。二叉树的深度可以定义为左子树和右子树深度的最大值加1。

  函数接受的参数root 是 NULL，即当前节点为空，那么返回深度为0。否则，递归地计算左子树和右子树的深度，并返回其中较大的一个，并加上1（当前节点的深度）。

//计算二叉树深度
int _BTDepth(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		int left_Height = _BTDepth(root->left) + 1;
		int right_Height = _BTDepth(root->right) + 1;
		if (left_Height >= right_Height) return left_Height;
		else return right_Height;
	}
}

//计算二叉树深度
int	BTDepth()
{
	return _BTDepth(_root);
}

  
计算二叉树节点数目：

  我们递归实现_Num_Of_TreeNode来计算二叉树的节点数目。

  首先我们接收一个指向二叉树节点的指针 root 作为参数。如果 root 是 NULL（也就是说，当前节点不存在），函数返回0。否则，则说明该二叉树的节点存在，函数返回1（对于当前节点） 加上左子树和右子树的节点数目。这是通过递归调用 _Num_Of_TreeNode 函数得到的。

//计算二叉树节点数目
int _Num_Of_TreeNode(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		return 1 + _Num_Of_TreeNode(root->left) + 
		_Num_Of_TreeNode(root->right);
	}
}

//计算二叉树节点数目
int Num_Of_TreeNode()
{
	return _Num_Of_TreeNode(_root);
}

  
计算二叉树叶子节点的数目:

  我们同样创建递归函数 _Num_Of_LeafNode来计算二叉树的叶子节点。

  我们接收一个指向二叉树节点的指针 root 作为参数。如果 root 是 NULL（也就是说，当前节点不存在），函数返回0。否则，函数首先递归地计算左子树和右子树的叶子节点数量，分别存储在 left_Num 和 right_Num 中。

  注意：如果 left_Num 和 right_Num 的和为0，这意味着当前节点是叶子节点，因此返回1。 如果 left_Num 和 right_Num 的和不为0，这意味着当前节点不是叶子节点，因此返回 left_Num 和 right_Num 的和。

//计算二叉树叶子节点的数目
int _Num_Of_LeafNode(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		int left_Num = _Num_Of_LeafNode(root->left);
		int right_Num = _Num_Of_LeafNode(root->right);
		if (left_Num + right_Num == 0)
		{
			return 1;
		}
		else
		{
			return left_Num + right_Num;
		}
	}
}

//计算二叉树叶子节点的数目
int Num_Of_LeafNode()
{
	return _Num_Of_LeafNode(_root);
}

  

2.4计算二叉树中度为 1 或 2 的结点数

  
计算度为1的节点个数：

  二叉树的递归函数大差不差，我们对于求不同的节点，只要加以它们的性质判断即可。

  如果二叉树的节点度为2，说明它们均有左右节点。 所以，此时函数返回的是左子树和右子树中1度节点的总和。

  只有右节点: 如果一个节点只有右子节点，那么它是1度节点。 因此，这个分支计算了右子树中的1度节点数量，并加上1（表示当前节点）。

  只有左节点: 与上述逻辑类似，如果一个节点只有左子节点， 那么它也是1度节点。这个分支计算了左子树中的1度节点数量，并加上1（表示当前节点）。

  无左右节点: 如果一个节点既没有左子节点也没有右子节点，那么它不是1度节点。函数返回0。

//计算度为1的节点个数
int _Num_Of_Degree_1(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right != NULL 
	|| root->left != NULL && root->right == NULL)
	{
		return 1 + _Num_Of_Degree_1(root->left) + 
		_Num_Of_Degree_1(root->right);
	}
	return  _Num_Of_Degree_1(root->left) + 
	_Num_Of_Degree_1(root->right);
}

//计算二叉树节点数目
int Num_Of_TreeNode()
{
	return _Num_Of_TreeNode(_root);
}

  
计算度为2的节点个数：

  和上面一样，我们实现计算一个二叉树中度为2的节点的数量。度为2的节点是指有两个子节点的节点。

  如果 root 的左右子节点都不为空(root->left != NULL and root->right != NULL)，则说明当前节点的度为2，返回1（对于当前节点）加上左子树和右子树的度为1的节点数量之和。

  只有右子节点不为空，则只返回右子树的度为1的节点数量。

  只有左子节点不为空，则只返回左子树的度为1的节点数量。

  左右子节点都为空，则当前节点不是度为2的节点，返回0。

//计算度为2的节点个数
int _Num_Of_Degree_2(BNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	else if(root->left != NULL && root->right != NULL)//均有左右节点
	{
		return 1 + _Num_Of_Degree_2(root->left) 
		+ _Num_Of_Degree_2(root->right);
	}
	return _Num_Of_Degree_2(root->right)+ _Num_Of_Degree_2(root->left);
}

//计算度为2的节点个数
int Num_Of_Degree_2()
{
	return _Num_Of_Degree_2(_root);
}

  

2.5判断2棵二叉树是否相似，若相似返回1，否则返回0

  这个函数是用来判断两棵二叉树是否相似的。相似二叉树的定义是：如果两棵二叉树的结构相同，即它们的左子树和右子树都是相似的，那么这两棵二叉树就是相似的。

  这个函数使用递归的方式进行检查。首先，如果两个节点都为空，那么它们显然是相似的。然后，如果两个节点都不为空，并且它们的左子树和右子树都是相似的，那么这两个节点也是相似的。 最后，如果以上条件都不满足，那么这两个节点就不相似。

//判断二叉树是否相似
int Is_Similar(BNode* t1, BNode* t2)
{
	if (t1 == NULL && t2 == NULL)
	{
		return 1;
	}
	else if (t1 && t2 && Is_Similar(t1->left, t2->left)
	 && Is_Similar(t1->right, t2->right))
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

            

3.全部源码

测试：

在这里插入图片描述
在这里插入图片描述
  

在这里插入图片描述
在这里插入图片描述

BinaryTree.h

#pragma once

#define BTDataType int

//定义二叉树节点
typedef struct BTreeNode
{
	BTDataType data;
	struct BTreeNode* left;
	struct BTreeNode* right;

	BTreeNode() 
	{
		data = -1;
		left = nullptr;
		right = nullptr;
	}

	BTreeNode(const int& _data)
	{
		data = _data;
		left = nullptr;
		right = nullptr;
	}
}BNode;

//定义二叉树
class BTree
{
public:
	//构造函数
	BTree()
	{
		_root = nullptr;

	}

	//析构函数
	~BTree()
	{
		DestroyTree(_root);
	}

	//递归创建二叉树
	void BTCreate()
	{
		BNode* tmp;
		_BTCreate(tmp);
		_root = tmp;
	}

	//前序遍历
	void PreOrder()
	{
		_PreOrder(_root);
		cout << endl;
	}

	//中序遍历
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	//后序遍历
	void PostOrder()
	{
		_PostOrder(_root);
		cout<<endl;
	}

	//计算二叉树深度
	int	BTDepth()
	{
		return _BTDepth(_root);
	}

	//计算二叉树节点数目
	int Num_Of_TreeNode()
	{
		return _Num_Of_TreeNode(_root);
	}

	//计算二叉树叶子节点的数目
	int Num_Of_LeafNode()
	{
		return _Num_Of_LeafNode(_root);
	}

	//计算度为1的节点个数
	int Num_Of_Degree_1()
	{
		return _Num_Of_Degree_1(_root);
	}

	//计算度为2的节点个数
	int Num_Of_Degree_2()
	{
		return _Num_Of_Degree_2(_root);
	}

	//判断二叉树是否相似
	int Is_Similar(BNode* t1, BNode* t2)
	{
		if (t1 == NULL && t2 == NULL)
		{
			return 1;
		}
		else if (t1 && t2 && Is_Similar(t1->left, t2->left) && Is_Similar(t1->right, t2->right))
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}

	//取根节点
	BNode*& GetRoot()
	{
		return _root;
	}

private:
	//递归创建二叉树
	void _BTCreate(BNode*& root)
	{
		char val;
		cin >> val;
		if (val == '.') root = nullptr;
		else
		{
			root = new BNode(val - '0');
			_BTCreate(root->left);
			_BTCreate(root->right);
		}
	}

	//前序遍历
	void _PreOrder(BNode* root)
	{
		if (root == nullptr)
		{
			cout << "NULL" << " ";
			return;
		}
	
		cout << root->data << " ";
		_PreOrder(root->left);
		_PreOrder(root->right);
	}

	//中序遍历
	void _InOrder(BNode* root)
	{
		if (root == nullptr)
		{
			cout << "NULL" << " ";
			return;
		}

		_InOrder(root->left);
		cout << root->data << " ";
		_InOrder(root->right);
	}

	//后序遍历
	void _PostOrder(BNode* root)
	{
		if (root == nullptr)
		{
			cout << "NULL" << " ";
			return;
		}

		_PostOrder(root->left);
		_PostOrder(root->right);
		cout << root->data << " ";
	}

	//计算二叉树深度
	int _BTDepth(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else
		{
			int left_Height = _BTDepth(root->left) + 1;
			int right_Height = _BTDepth(root->right) + 1;
			if (left_Height >= right_Height) return left_Height;
			else return right_Height;
		}
	}

	//计算二叉树节点数目
	int _Num_Of_TreeNode(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else
		{
			return 1 + _Num_Of_TreeNode(root->left) + _Num_Of_TreeNode(root->right);
		}
	}

	//计算二叉树叶子节点的数目
	int _Num_Of_LeafNode(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else
		{
			int left_Num = _Num_Of_LeafNode(root->left);
			int right_Num = _Num_Of_LeafNode(root->right);
			if (left_Num + right_Num == 0)
			{
				return 1;
			}
			else
			{
				return left_Num + right_Num;
			}
		}
	}

	//计算度为1的节点个数
	int _Num_Of_Degree_1(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		if (root->left == NULL && root->right != NULL || root->left != NULL && root->right == NULL)
		{
			return 1 + _Num_Of_Degree_1(root->left) + _Num_Of_Degree_1(root->right);
		}
		return  _Num_Of_Degree_1(root->left) + _Num_Of_Degree_1(root->right);
	}

	//计算度为2的节点个数
	int _Num_Of_Degree_2(BNode* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		else if(root->left != NULL && root->right != NULL)//均有左右节点
		{
			return 1 + _Num_Of_Degree_2(root->left) + _Num_Of_Degree_2(root->right);
		}
		return  _Num_Of_Degree_2(root->left) + _Num_Of_Degree_2(root->right);
	}

	//销毁二叉树
	void DestroyTree(BNode*& root) 
	{
		if (root == NULL) 
		{
			return;
		}

		BNode* lroot = root->left;
		BNode* rroot = root->right;
		delete root;
		if (lroot != NULL)
		{
			DestroyTree(lroot);
		}
		if (rroot != NULL)
		{
			DestroyTree(rroot);
		}
	}

private:
	BNode* _root;
};

            

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;
 
#include"BinaryTree.h" 

void binary_Test()
{
	BTree bt1;
	BTree bt2;
	cout << "输入第一棵树的前序遍历（空树请用 . 代替）:";
	bt1.BTCreate();
	cout << "输入第二棵树的前序遍历（空树请用 . 代替）:";
	bt2.BTCreate(); 
	cout << "第一棵树的前序遍历为:";
	bt1.PreOrder();
	cout << "第一棵树的中序遍历为:"; 
	bt1.InOrder();	
	cout << "第一棵树的后序遍历为:"; 
	bt1.PostOrder();
	cout << "第一棵树的深度为:" << bt1.BTDepth() << endl;
	cout << "第一棵树中的节点数:" << bt1.Num_Of_TreeNode() << endl;
	cout << "第一棵树中的叶子节点数:" << bt1.Num_Of_LeafNode() << endl;
	cout << "第一棵树中度为1的节点数:" << bt1.Num_Of_Degree_1() << endl;
	cout << "第一棵树中度为2的节点数:" << bt1.Num_Of_Degree_2() << endl;
	cout << endl;
	cout << "第二棵树的前序遍历为:";
	bt2.PreOrder();
	cout << "第二棵树的中序遍历为:";
	bt2.InOrder();
	cout << "第二棵树的后序遍历为:";
	bt2.PostOrder();
	cout << "第二棵树的深度为:" << bt2.BTDepth() << endl;
	cout << "第二棵树中的节点数:" << bt2.Num_Of_TreeNode() << endl;
	cout << "第二棵树中的叶子节点数:" << bt2.Num_Of_LeafNode() << endl;
	cout << "第二棵树中度为1的节点数:" << bt2.Num_Of_Degree_1() << endl;
	cout << "第二棵树中度为2的节点数:" << bt2.Num_Of_Degree_2() << endl;
	cout << "两棵树是否相似:" << bt1.Is_Similar(bt1.GetRoot(), bt2.GetRoot());
}

int main()
{
	binary_Test();
	return 0;
}

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

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

相关文章

c语言进阶部分详解（详细解析动态内存管理）

c语言进阶部分详解（详细解析动态内存管理）

上篇文章介绍了枚举&#xff0c;联合相关的内容&#xff0c;大家可以点击链接进行浏览&#xff1a;c语言进阶部分详解&#xff08;详细解析自定义类型——枚举&#xff0c;联合&#xff08;共用体&#xff09;&#xff09;-CSDN博客 各种源码大家可以去我的github主页进行查找…
阅读更多...
业务设计——海量订单数据如何存储和查询

业务设计——海量订单数据如何存储和查询

冷热数据架构 假设我们考虑 12306 单个假期的人流量为 2 亿人次&#xff0c;这一估算基于每年的三个主要假期&#xff1a;五一、国庆和春节。这些假期通常都有来回的流动&#xff0c;因此数据存储与计算的公式变为&#xff1a;2 * (3*2) 12 亿&#xff0c;即每年的假期总人次达…
阅读更多...
el -table 多层级嵌套

el -table 多层级嵌套

只要你后端可以查到数据这个层级可以无限嵌套 这里用了懒加载&#xff0c;每次点击的时候将当前点击的父级id作为查询条件&#xff0c;向后端发送请求&#xff0c;来获取他子级的数据&#xff0c;并不是将所有数据查出来拼接返回的。 前端代码 <el-table:data"dataLis…
阅读更多...
12、SpringCloud -- redis库存和redis预库存保持一致、优化后的压测效果

12、SpringCloud -- redis库存和redis预库存保持一致、优化后的压测效果

目录 redis库存和redis预库存保持一致问题的产生需求：代码：测试：优化后的压测效果之前的测试数据优化后的测试数据redis库存和redis预库存保持一致 redis库存是指初始化是从数据库中获取最新的秒杀商品列表数据存到redis中 redis的预库存是指每个秒杀商品每次成功秒杀之后…
阅读更多...
【JAVA学习笔记】52 - 本章作业

【JAVA学习笔记】52 - 本章作业

1.字符反转 注意String是final的不能改变需要toCharArray改成char数组 返回String需要将char改成valueOf改为String public class HomeWork01 {public static void main(String[] args) {String str "0123456789";//改变的是char&#xff0c;和str无关try {System…
阅读更多...
项目|金额场景计算BigDecimal使用简记

项目|金额场景计算BigDecimal使用简记

前言 在实际项目开发中&#xff0c;我们经常会遇到一些金额计算&#xff0c;分摊等问题&#xff0c;通常我们都使用java.math.BigDecimal 来完成各种计算&#xff0c;避免使用浮点数float,double来计算金额&#xff0c;以免丢失精度&#xff0c;以下是博主部分使用场景和使用Bi…
阅读更多...
element-plus走马灯不显示

element-plus走马灯不显示

问题描述 依赖正确&#xff0c;代码用法正确&#xff0c;但是element-plu走马灯就是不显示&#xff01;&#xff01; <div class"content"><el-carousel height"150px" width"200px"><el-carousel-item v-for"item in 4&qu…
阅读更多...
联想电脑thinkpad x13摄像头打不开，史上最全的针对联想电脑摄像头的解决方案

联想电脑thinkpad x13摄像头打不开，史上最全的针对联想电脑摄像头的解决方案

前言 最近面试&#xff0c;临近面试的前30min&#xff0c;发现摄像头打不开。具体情况如下&#xff1a; 这可没把我吓坏&#xff0c;我可是要露脸的&#xff0c;最后在我的不屑努力下&#xff0c;我选择了手机视频面试&#xff0c;很干。未来的几天都在琢磨这玩意儿了&#…
阅读更多...
Docker 部署spring-boot项目（超详细 包括Docker详解、Docker常用指令整理等）

Docker 部署spring-boot项目（超详细 包括Docker详解、Docker常用指令整理等）

文章目录 DockerDocker的定义Docker有哪些作用Docker有哪些好处使用docker部署springboot项目安装docker创建Dockerfile镜像文件执行镜像文件(Dockerfile文件)查看Docker镜像启动容器查看Docker中运行的容器查看服务容器日志 Docker常用指令查看docker安装目录启动Docker停止Do…
阅读更多...
MGRE环境下的OSPF

MGRE环境下的OSPF

实验拓扑 需求 1 R6为ISP只能配置IP地址&#xff0c;R1-R5的环回为私有网段 2 R1/4/5为全连的MGRE结构&#xff0c;R1/2/3为星型的拓扑结构&#xff0c;R1为中心站点 3 所有私有网段可以互相通讯&#xff0c;私有网段使用OSPF完成。 IP规划 配置IP R1 # interface GigabitEt…
阅读更多...
第三次ACM校队周赛考核题+生活随笔

第三次ACM校队周赛考核题+生活随笔

本周ACM校队周赛考核题 1.简单数学&#xff08;签到题&#xff09; 题目&#xff1a; Joker想要买三张牌&#xff0c;但是三张牌太少了&#xff0c;老板不卖&#xff0c;除非Joker算出老板给出的数学题。 现在老板给出t组数据&#xff0c;每一组数据有三个数a,b,c&#xff0c…
阅读更多...
【从0到1设计一个网关】整合Nacos-服务注册与服务订阅的实现

【从0到1设计一个网关】整合Nacos-服务注册与服务订阅的实现

文章目录 Nacos定义服务注册与订阅方法服务信息加载与配置实现将网关注册到注册中心实现服务的订阅 Nacos Nacos提供了许多强大的功能&#xff1a; 比如服务发现、健康检测。 Nacos支持基于DNS和基于RPC的服务发现。 同时Nacos提供对服务的实时的健康检查&#xff0c;阻止向不…
阅读更多...
【JavaSE】运算符详解及与C语言中的区别

【JavaSE】运算符详解及与C语言中的区别

在文章的最后&#xff0c;总结了Java与C语言的某些不同点 目录 一、什么是运算符 二、算术运算符 1.基本四则运算符 2.增量运算符 3.自增/自减运算符/-- 三、关系运算符 四、逻辑运算符&#xff08;重点&#xff09; 1.逻辑与&& 2.逻辑或|| 3.逻辑非 4.补…
阅读更多...
SQL Server 安装失败 服务“MSSQLServerOLAPService”启动请求失败 一定有效的解决方案

SQL Server 安装失败 服务“MSSQLServerOLAPService”启动请求失败 一定有效的解决方案

问题描述 首次安装 SQL Server 2022&#xff0c;在安装结束时出现弹窗“无法启动服务。原因&#xff1a;服务“MSSQLServerOLAPService”启动请求失败”。 点击“确定”按钮后&#xff0c;出现新弹窗。 问题原因 在Windows服务中手动启动“MSSQLServerOLAPService”&#x…
阅读更多...
建筑木模板现货供应，广东隧道地铁木模板批发。

建筑木模板现货供应，广东隧道地铁木模板批发。

我们是一家专业供应建筑木模板的公司&#xff0c;提供广东地区的现货供应服务。我们特别推荐我们的隧道地铁木模板&#xff0c;专为隧道和地铁工程而设计&#xff0c;为工程施工提供优质可靠的支撑材料。我们的隧道地铁木模板采用高品质的木材制造而成&#xff0c;具有卓越的强…
阅读更多...
muduo源码剖析之Buffer缓冲区类

muduo源码剖析之Buffer缓冲区类

简介 Buffer封装了一个可变长的buffer&#xff0c;支持廉价的前插操作&#xff0c;以及内部挪腾操作避免额外申请空间 使用vector作为缓冲区(可自动调整扩容) 设计图 源码剖析 已经编写好注释 buffer.h // Copyright 2010, Shuo Chen. All rights reserved. // http://c…
阅读更多...
msvcp140.dll丢失的正确解决方法

msvcp140.dll丢失的正确解决方法

在使用电脑中我们经常会遇到一些错误提示&#xff0c;其中之一就是“msvcp140.dll丢失”。这个错误通常会导致某些应用程序无法正常运行。为了解决这个问题&#xff0c;我们需要采取一些措施来修复丢失的msvcp140.dll文件。本文将介绍6个不同的解决方法&#xff0c;帮助读者解决…
阅读更多...
java lombok

java lombok

Lombok是一个实用的Java类库&#xff0c;可以通过简单的注解来简化和消除一些必须有但显得很臃肿的Java代码。 通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法&#xff0c;并可以自动化生成日志变量&#xff0c;简化java开发、提高效率&#…
阅读更多...
AI：39-基于深度学习的车牌识别检测

AI：39-基于深度学习的车牌识别检测

🚀 本文选自专栏：AI领域专栏 从基础到实践，深入了解算法、案例和最新趋势。无论你是初学者还是经验丰富的数据科学家，通过案例和项目实践，掌握核心概念和实用技能。每篇案例都包含代码实例，详细讲解供大家学习。 📌📌📌本专栏包含以下学习方向： 机器学习、深度学…
阅读更多...
不用动脑子的技巧！已知二叉树的前序中序遍历，确定二叉树/求后序遍历

不用动脑子的技巧！已知二叉树的前序中序遍历，确定二叉树/求后序遍历

根据前&#xff08;后&#xff09;序、中序&#xff0c;确定二叉树&#xff0c;高妙的方法&#xff01;&#xff01;&#xff01; 二叉树的前中后序遍历⏩巧妙的方法&#xff01;根据前序遍历和中序遍历&#xff0c;确定二叉树例题1例题2 根据后序遍历和中序遍历&#xff0c;确…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023