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

文章目录

  • 数据结构上机实验
    • 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;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

在3分钟内使用AI-Chat生成精美PPT（附AI工具）

在3分钟内使用AI-Chat生成精美PPT（附AI工具）

前言 在人工智能的大趋势下&#xff0c;AI-Chat是一款令人惊叹的技术。它用强大的自然语言处理技术帮助我们快速生成PPT&#xff0c;提高工作效率。本文将介绍使用ChatAI-Chat生成PPT的方法&#xff0c;以及使用Mindshow转换为炫酷的演示文稿。让技术为我们节省时间&#xff0c…
阅读更多...
【数据结构】数组和字符串（十）：稀疏矩阵的链接存储：十字链表的矩阵操作（加法、乘法、转置）

【数据结构】数组和字符串（十）：稀疏矩阵的链接存储：十字链表的矩阵操作（加法、乘法、转置）

文章目录 4.2.1 矩阵的数组表示4.2.2 特殊矩阵的压缩存储a. 对角矩阵的压缩存储b~c. 三角、对称矩阵的压缩存储d. 稀疏矩阵的压缩存储——三元组表4.2.3三元组表的转置、加法、乘法、操作4.2.4十字链表0. 十字链表的基本操作1. 矩阵加法2. 矩阵乘法3. 矩阵转置4. 主函数 5. 代码…
阅读更多...
Binder机制总结笔记

Binder机制总结笔记

Binder机制总结笔记 什么是Binder&#xff1f; Binder的Android特有的IPC通信机制。Android的四大组件Activity、Service、Broadcast、ContentProvider&#xff0c;不同的App等都运行在不同的进程内&#xff0c;他们之间的通信都需要依靠Binder完成。因此Binder在整个Android系…
阅读更多...
ARM | 传感器必要总线IIC

ARM | 传感器必要总线IIC

IIC总线介绍 1.谈谈你对IIC总线理解&#xff1f; 1&#xff09;IIC总线是串行半双工同步总线,主要用于连接整体电路 2&#xff09;SCL/SDA作用:IIC是两线制,一根是时钟线SCK,用于控制什么时候进行进行数据传输,时钟信号由主机发出; 另一根是数据线SDA,用于进行数据传输,可以从…
阅读更多...
7.多线程之单例模式

7.多线程之单例模式

单例模式 文章目录 单例模式1. 什么是单例模式2. 饿汉模式3. 懒汉模式3.1 单线程版&#xff1a;3.2 多线程版 1. 什么是单例模式 单例模式是一种设计模式&#xff0c;常见的设计模式还有工厂模式、建造者模式等。 设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码…
阅读更多...
“人类高质量数据”如何训练计算机视觉模型？

“人类高质量数据”如何训练计算机视觉模型？

人类的视觉系统可以复制吗&#xff1f; 答案是肯定的。 计算机视觉 (Computer Vision) 技术的不断普及&#xff0c;让机器识别和处理图像就像人的大脑一样&#xff0c;且速度更快、更准确。 机器像人类一样去“思考” 计算机视觉 (Computer Vision) 是近年来人工智能增长最快…
阅读更多...
玩转视图变量，轻松实现动态可视化数据分析

玩转视图变量，轻松实现动态可视化数据分析

前言 在当今数据驱动的世界中&#xff0c;数据分析已经成为了企业和组织中不可或缺的一部分。传统的静态数据分析方法往往无法满足快速变化的业务需求和实时决策的要求。为了更好地应对这些挑战&#xff0c;观测云的动态可视化数据分析应运而生。 在动态可视化数据分析中&…
阅读更多...
微机原理：汇编语言程序设计

微机原理：汇编语言程序设计

文章目录 一、汇编格式1、文字简述2、代码表述 二、汇编语言结构说明1、方式选择伪指令2、段定义语句3、段约定语句4、汇编结束语句5、返回DOS语句 三、实例1、例子2、汇编语言程序开发过程 四、功能调用DOS功能调用1、功能号01H2、功能号02H3、功能号09H4、功能号0AH5、举例 B…
阅读更多...
Ubuntu编译 PCL 1.13.1 详细流程

Ubuntu编译 PCL 1.13.1 详细流程

Ubuntu编译 PCL 1.13. 详细流程 一、编译环境二、虚拟机准备1. 虚拟机扩容2. 配置交换分区 三、Cmake - gui 生成 MakeFile1. 解决 flann 依赖问题2. 配置 Cmake 四、编译安装1.编译&#xff1a;2. 安装 一、编译环境 Ubuntu&#xff1a;Ubuntu 20.04 VMware&#xff1a;VMwar…
阅读更多...
统计学习方法 支持向量机（下）

统计学习方法 支持向量机（下）

文章目录 统计学习方法 支持向量机&#xff08;下&#xff09;非线性支持向量机与和核函数核技巧正定核常用核函数非线性 SVM 序列最小最优化算法两个变量二次规划的求解方法变量的选择方法SMO 算法 统计学习方法 支持向量机&#xff08;下&#xff09; 学习李航的《统计学习方…
阅读更多...
VS工程的“多dll与exe文件合并”

VS工程的“多dll与exe文件合并”

运行环境 ILMerge插件 1、打开 VS的“工具 - NuGet包管理器 - 管理解决方案的NuGet程序包” 2、在浏览中搜索“ILMerge”&#xff0c;在官方源中&#xff0c;3.0.41版本的插件已不支持使用了 3、下拉列表其他版本可以安装&#xff0c;使用3.0.40 4、下载封装好的“ILMerge”任…
阅读更多...
React-快速搭建开发环境

React-快速搭建开发环境

1.安装 说明&#xff1a;react-excise-01是创建的文件名 npx create-react-app react-excise-01 2. 打开文件 说明:we suggest that you begin by typing:下面即是步骤。 cd react-excise-01 npm start 3.显示
阅读更多...
B. Qingshan Loves Strings（贪心规律）

B. Qingshan Loves Strings（贪心规律）

Problem - B - Codeforces 解析&#xff1a; 首先判断 t 字符串是不是相邻不同并且两端不同。 然后遍历 s 并且判断每一个相邻的相同字符&#xff0c;必须 t 字符符合并且两侧不同。 #include<bits/stdc.h> using namespace std; #define int long long const int N2e55…
阅读更多...
计算机视觉注意力机制小盘一波 （学习笔记）

计算机视觉注意力机制小盘一波 （学习笔记）

将注意力的阶段大改分成了4个阶段 1.将深度神经网络与注意力机制相结合&#xff0c;代表性方法为RAM ⒉.明确预测判别性输入特征&#xff0c;代表性方法为STN 3.隐性且自适应地预测潜在的关键特征&#xff0c;代表方法为SENet 4.自注意力机制 通道注意力 在深度神经网络中…
阅读更多...
状态机的设计与实现

状态机的设计与实现

写作目的 好久没有写博客进行输出了&#xff0c;是时候需要水一篇了&#xff0c;嘻嘻。 正好项目中使用了状态机&#xff0c;也借此分享一下系统中状态机的项目落地经验。 什么是状态机 以在某宝下单为例&#xff0c;在点击下单后&#xff0c;此时订单就已经创建了&#xff…
阅读更多...
基于Python+pyecharts 实现国内上映电影票房评分可视化分析项目源码

基于Python+pyecharts 实现国内上映电影票房评分可视化分析项目源码

基于Pythonpyecharts 实现国内上映电影票房评分可视化分析项目源码 项目内容 统计2018年在国内上映的所有电影&#xff0c;分别获取上映电影的票房、评分&#xff08;豆瓣、猫眼、时光、imdb&#xff09;、类型、上映日期、演员、导演等数据。利用所获数据绘图&#xff0c;对…
阅读更多...
人工智能基础_机器学习006_有监督机器学习_正规方程的公式推导_最小二乘法_凸函数的判定---人工智能工作笔记0046

人工智能基础_机器学习006_有监督机器学习_正规方程的公式推导_最小二乘法_凸函数的判定---人工智能工作笔记0046

我们来看一下公式的推导这部分比较难一些, 首先要记住公式,这个公式,不用自己理解,知道怎么用就行, 比如这个(mA)T 这个转置的关系要知道 然后我们看这个符号就是求X的导数,X导数的转置除以X的导数,就得到单位矩阵, 可以看到下面也是,各种X的导数,然后计算,得到对应的矩阵结…
阅读更多...
php之 角色的权限管理（RBAC）详解

php之 角色的权限管理（RBAC）详解

RBAC&#xff08;Role-based access control&#xff09;是一种常见的权限管理模型&#xff0c;通过将用户分配至特定的角色&#xff0c;以及为角色分配访问权限&#xff0c;实现了权限管理的目的。以下是关于RBAC的详细解释&#xff1a; 角色&#xff1a;RBAC模型的核心是角色…
阅读更多...
Java电商平台 - API 接口设计之 token、timestamp、sign 具体架构与实现|电商API接口接入

Java电商平台 - API 接口设计之 token、timestamp、sign 具体架构与实现|电商API接口接入

一&#xff1a;token 简介 Token&#xff1a;访问令牌access token, 用于接口中, 用于标识接口调用者的身份、凭证&#xff0c;减少用户名和密码的传输次数。一般情况下客户端(接口调用方)需要先向服务器端申请一个接口调用的账号&#xff0c;服务器会给出一个appId和一个key, …
阅读更多...
常用JQuery插件汇总

常用JQuery插件汇总

Jquery插件&#xff0c;数字动画特效&#xff0c;从n到m数字跳动JJ​​​​​​​CountUp.jsA javascript class that animates a numerical value by counting to it.http://inorganik.github.io/countUp.js/
阅读更多...
最新文章

Copyright @ 2022~2023