C++笔记---二叉搜索树

news2024/11/13 15:19:21

1. 二叉搜索树的概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

• 若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值。

• 若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值。

• 它的左右子树也分别为二叉搜索树。

• 二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，后续我们学习map/set/multimap/multiset系列容器底层就是二叉搜索树，其中map/set不支持插入相等值，multimap/multiset支持插入相等值。

除了支不支持插入相同的值以外，二叉搜索树还可以按照其带的值分为两类：key和key/value。

key：只带一个值key

key/value：带两个相绑定的值，构建二叉树与进行查找时都以key为准。 

这两种搜索二叉树的实现大同小异，接下来的介绍中我们以key类型为例，key/value类型的只需要在结点的结构中加上value即可(函数随之微调)。

2. 二叉搜索树的性能分析

二叉搜索树查找的时间复杂度与其高度相同。

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其高度为： O(log_{2}N)

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其高度为： O(N/2)

所以综合而言二叉搜索树增删查改时间复杂度为： O(N)

那么这样的效率显然是无法满足我们需求的，为了使二叉搜索树的搜索效率足够高，我们需要使得二叉搜索树尽可能地接近完全二叉树，于是就有了我们之后会讲到的平衡二叉搜索树，以及AVL树和红黑树等。

另外需要说明的是，二分查找也可以实现 O(logN) 级别的查找效率，但是二分查找有两大缺陷：

1. 需要存储在支持下标随机访问的结构中，并且有序。

2. 插入和删除数据效率很低，因为存储在下标随机访问的结构中，插入和删除数据一般需要挪动数据。这里也就体现出了平衡二叉搜索树的价值。

 3. 二叉搜索树的实现

3.1 结点定义及二叉搜索树类的框架

template<class K>
struct BSTreeNode
{
	K _key;
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
    //强制生成默认构造
	BSTree() = default;
    //拷贝构造
	BSTree(const BSTree& tree);
    //析构
	~BSTree();
    //赋值重载
	BSTree& operator=(BSTree tree);
    //插入
	bool Insert(const K& key);
	//查找
	Node* Find(const K& key);
    //删除
	bool Erase(const K& key);
	//中序遍历
	void InOrder();

private:
    //辅助拷贝构造进行递归拷贝
	Node* Construct(Node* root);
    //辅助析构函数进行递归释放结点
	void Destroy(Node* root);
    //辅助进行递归中序遍历
	void _InOrder(Node* root);

private:
	Node* _root = nullptr;
};

3.2 默认成员函数

3.2.1 构造函数

由于我们给了_root缺省值，所以编译器自动生成的默认构造函数就够用。

而拷贝构造需要我们自己实现深拷贝，即访问被拷贝的树的全部结点并拷贝链接。

对于树形结构，访问一棵树的全部结点，递归永远是最方便的选择。可是，如何在类内部设计递归函数呢？毕竟需要直接将树结点的指针作为参数才好实现递归。

这时，我们就可以选择在递归函数的外面套一层成员函数的壳。

BSTree() = default;

BSTree(const BSTree& tree)
{
	_root = Construct(tree._root);
}
Node* Construct(Node* root)
{
	if (root == nullptr)
		return nullptr;

	Node* copy = new Node(root->_key);
	copy->_left = Construct(root->_left);
	copy->_right = Construct(root->_right);
	return copy;
}
3.2.2 赋值重载

有了拷贝构造，就可以考虑现代写法：

BSTree& operator=(BSTree tree)
{
	swap(_root, tree._root);
	return *this;
}
3.2.3 析构函数

递归访问每个结点并释放，同理需要套一层外壳：

~BSTree()
{
	Destroy(_root);
	_root = nullptr;
}
void Destroy(Node* root)
{
	if (root == nullptr)
		return;

	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

3.3 二叉搜索树的插入

1. 树为空，则直接新增结点，赋值给root指针。

2. 树不空，按二叉搜索树性质，插入值比当前结点大往右走，插入值比当前结点小往左走，找到空位置，插入新结点。

3. 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点。（要注意的是要保持逻辑一致性，插入相等的值不要一会往右走，一会往左走）

下面的代码是不支持插入相等的值的情形： 

bool Insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	
	Node* cur = _root, *parent = nullptr;
	while (cur)
	{
		parent = cur;
		if (key < cur->_key)
			cur = cur->_left;
		else if (key > cur->_key)
			cur = cur->_right;
		else
			return false;
	}

	cur = new Node(key);
	if (key < parent->_key)
		parent->_left = cur;
	else
		parent->_right = cur;

	return true;
}

 3.4 二叉搜索树的查找

1. 从根开始比较，查找x，x比根的值大则往右边走查找，x比根值小则往左边走查找。

2. 最多查找高度次，走到到空，还没找到，这个值不存在。

3. 如果不支持插入相等的值，找到x即可返回。

4. 如果支持插入相等的值，意味着有多个x存在，一般要求查找中序的第一个x。如下图，查找3，要找到1的右孩子的那个3返回。

个人认为，如果支持插入相同的值，最好是把相同的值插入到右子树。这样一来，按照前序遍历找到的第一个x就是中序遍历的第一个x（两种遍历方式都是最后查找右子树）。

 3.5 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回false。

如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为N）

1. 要删除结点N左右孩子均为空

2. 要删除的结点N左孩子位空，右孩子结点不为空

3. 要删除的结点N右孩子位空，左孩子结点不为空

4. 要删除的结点N左右孩子结点均不为空

对应以上四种情况的解决方案：

1. 把N结点的父亲对应孩子指针指向空，直接删除N结点（情况1可以当成2或者3处理，效果是一样的）

2. 把N结点的父亲对应孩子指针指向N的右孩子，直接删除N结点

3. 把N结点的父亲对应孩子指针指向N的左孩子，直接删除N结点

4. 无法直接删除N结点，因为N的两个孩子无处安放，只能用替换法删除。找N左子树的值最大结点LR(最右结点)或者N右子树的值最小结点RL(最左结点)替代N，因为这两个结点中任意一个，放到N的位置，都满足二叉搜索树的规则。替代N的意思就是N和R的两个结点的值交换，转而变成删除R结点，R结点符合情况2或情况3，可以直接删除。

另外，在每种情况中，都要注意判断被删除的结点是否为根结点_root，因为在删除的过程中需要记录被删除结点的父节点，而根节点没有父节点，在通用逻辑下会导致对空指针的访问。

bool Erase(const K& key)
{
	Node* del = _root, *parent = nullptr;
	while (del && del->_key != key)
	{
		parent = del;
		if (key < del->_key)
			del = del->_left;
		else
			del = del->_right;
	}
	if (del == nullptr)
		return false;

	if (del->_left == nullptr)//左结点为空（或者左右都为空）
	{
		if (parent == nullptr)//被删除的是根结点
		{
			_root = del->_right;
		}
		else if (del->_key < parent->_key)
			parent->_left = del->_right;
		else
			parent->_right = del->_right;

		delete del;
	}
	else if (del->_right == nullptr)//右结点为空且左节点不为空
	{
		if (parent == nullptr)//被删除的是根结点
		{
			_root = del->_left;
		}
		else if (del->_key < parent->_key)
			parent->_left = del->_left;
		else
			parent->_right = del->_left;

		delete del;
	}
	else//左右结点都不为空
	{
		Node* replace = del->_right;
		parent = del;
		while (replace->_left)
		{
			parent = replace;
			replace = replace->_left;
		}
		del->_key = replace->_key;
		del->_value = replace->_value;
		if (parent->_right == replace)
			parent->_right = replace->_right;
		else
			parent->_left = replace->_right;
		delete replace;
	}

	return true;
}

3.6 完整代码

template<class K>
struct BSTreeNode
{
	K _key;
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree() = default;

	BSTree(const BSTree& tree)
	{
		_root = Construct(tree._root);
	}

	~BSTree()
	{
		Destroy(_root);
		_root = nullptr;
	}

	BSTree& operator=(BSTree tree)
	{
		swap(_root, tree._root);
		return *this;
	}

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		
		Node* cur = _root, *parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (key < cur->_key)
				cur = cur->_left;
			else if (key > cur->_key)
				cur = cur->_right;
			else
				return false;
		}

		cur = new Node(key);
		if (key < parent->_key)
			parent->_left = cur;
		else
			parent->_right = cur;

		return true;
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key == cur->_key)
				return cur;
			else if (key < cur->_key)
				cur = cur->_left;
			else
				cur = cur->_right;
		}

		return nullptr;
	}

	bool Erase(const K& key)
	{
		Node* del = _root, *parent = nullptr;
		while (del && del->_key != key)
		{
			parent = del;
			if (key < del->_key)
				del = del->_left;
			else
				del = del->_right;
		}
		if (del == nullptr)
			return false;

		if (del->_left == nullptr)
		{
			if (parent == nullptr)
			{
				_root = del->_right;
			}
			else if (del->_key < parent->_key)
				parent->_left = del->_right;
			else
				parent->_right = del->_right;

			delete del;
		}
		else if (del->_right == nullptr)
		{
			if (parent == nullptr)
			{
				_root = del->_left;
			}
			else if (del->_key < parent->_key)
				parent->_left = del->_left;
			else
				parent->_right = del->_left;

			delete del;
		}
		else
		{
			Node* replace = del->_right;
			parent = del;
			while (replace->_left)
			{
				parent = replace;
				replace = replace->_left;
			}
			del->_key = replace->_key;
			del->_value = replace->_value;
			if (parent->_right == replace)
				parent->_right = replace->_right;
			else
				parent->_left = replace->_right;
			delete replace;
		}

		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:
	Node* Construct(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* copy = new Node(root->_key);
		copy->_left = Construct(root->_left);
		copy->_right = Construct(root->_right);
		return copy;
	}

	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

private:
	Node* _root = nullptr;
};

4. 二叉搜索树key和key/value的使用场景

4.1 key搜索场景

只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，搜索场景只需要判断key在不在。

key的搜索场景实现的二叉树搜索树支持增删查，但是不支持修改，因为修改key会破坏搜索树结构。

场景1：小区无人值守车库，小区车库买了车位的业主车才能进小区，那么物业会把买了车位的业主的车牌号录入后台系统，车辆进入时扫描车牌在不在系统中，在则抬杆，不在则提示非本小区车辆，无法进入。


场景2：检查一篇英文文章单词拼写是否正确，将词库中所有单词放入二叉搜索树，读取文章中的单词，查找是否在二叉搜索树中，不在则波浪线标红提示。

4.2 key/value搜索场景

每一个关键码key，都有与之对应的值value，value可以任意类型对象。

树的结构中(结点)除了需要存储key还要存储对应的value，增/删/查还是以key为关键字走二叉搜索树的规则进行比较，可以快速查找到key对应的value。

key/value的搜索场景实现的二叉树搜索树支持修改，但是同样不支持修改key，可以修改value。

场景1：简单中英互译字典，树的结构中(结点)存储key(英文)和vlaue(中文)，搜索时输入英文，则同时查找到了英文对应的中文。

场景2：商场无人值守车库，入口进场时扫描车牌，记录车牌(key)和入场时间(value)，出口离场时，扫描车牌，查找入场时间，用当前时间-入场时间计算出停车时长，计算出停车费用，缴费后抬杆，车辆离场。

场景3：统计一篇文章中单词(key)出现的次数(value)，读取一个单词，查找单词是否存在，不存在这个说明第一次出现，（单词，1），单词存在，则++单词对应的次数。

void TestBSTree()
{
    // 四个单词的简单词典
	BSTree<string, string> dict;
	dict.Insert("insert", "插入");
	dict.Insert("erase", "删除");
	dict.Insert("left", "左边");
	dict.Insert("string", "字符串");

	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << str << ":" << ret->_value << endl;
		}
		else
		{
			cout << "单词拼写错误" << endl;
		}
	}


    // 统计水果出现次数
	string strs[] = { "苹果", "西瓜", "苹果", "樱桃", "苹果", "樱桃", "苹果", "樱桃", "苹果" };
	// 统计水果出现的次
	BSTree<string, int> countTree;
	for (auto str : strs)
	{
		auto ret = countTree.Find(str);
		if (ret == nullptr)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();
}

 

 4.3 key/value版本二叉搜索树

template<class K, class V>
struct BSTreeNode
{
	K _key;
	V _value;
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

	BSTreeNode(const K& key, const V& value)
		:_key(key)
		,_value(value)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
public:
	BSTree() = default;

	BSTree(const BSTree& tree)
	{
		_root = Construct(tree._root);
	}

	~BSTree()
	{
		Destroy(_root);
		_root = nullptr;
	}

	BSTree& operator=(BSTree tree)
	{
		swap(_root, tree._root);
		return *this;
	}

	bool Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key, value);
			return true;
		}
		
		Node* cur = _root, *parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (key < cur->_key)
				cur = cur->_left;
			else if (key > cur->_key)
				cur = cur->_right;
			else
				return false;
		}

		cur = new Node(key, value);
		if (key < parent->_key)
			parent->_left = cur;
		else
			parent->_right = cur;

		return true;
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key == cur->_key)
				return cur;
			else if (key < cur->_key)
				cur = cur->_left;
			else
				cur = cur->_right;
		}

		return nullptr;
	}

	bool Erase(const K& key)
	{
		Node* del = _root, *parent = nullptr;
		while (del && del->_key != key)
		{
			parent = del;
			if (key < del->_key)
				del = del->_left;
			else
				del = del->_right;
		}
		if (del == nullptr)
			return false;

		if (del->_left == nullptr)
		{
			if (parent == nullptr)
			{
				_root = del->_right;
			}
			else if (del->_key < parent->_key)
				parent->_left = del->_right;
			else
				parent->_right = del->_right;

			delete del;
		}
		else if (del->_right == nullptr)
		{
			if (parent == nullptr)
			{
				_root = del->_left;
			}
			else if (del->_key < parent->_key)
				parent->_left = del->_left;
			else
				parent->_right = del->_left;

			delete del;
		}
		else
		{
			Node* replace = del->_right;
			parent = del;
			while (replace->_left)
			{
				parent = replace;
				replace = replace->_left;
			}
			del->_key = replace->_key;
			del->_value = replace->_value;
			if (parent->_right == replace)
				parent->_right = replace->_right;
			else
				parent->_left = replace->_right;
			delete replace;
		}

		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:
	Node* Construct(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* copy = new Node(root->_key, root->_value);
		copy->_left = Construct(root->_left);
		copy->_right = Construct(root->_right);
		return copy;
	}

	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_key << ":" << root->_value << " ";
		_InOrder(root->_right);
	}

private:
	Node* _root = nullptr;
};

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

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

相关文章

【CTF Reverse】XCTF GFSJ1092 easyEZbaby_app Writeup（Android+逆向工程+Java）

【CTF Reverse】XCTF GFSJ1092 easyEZbaby_app Writeup（Android+逆向工程+Java）

easyEZbaby_app 究极简单的安卓逆向 解法 得到一个 apk 安装包。 用 jadx 打开&#xff0c;搜索文本 flag&#xff0c;加载所有。 flag 是 obj obj2&#xff0c;来自用户的用户名和密码。 Override // android.view.View.OnClickListenerpublic void onClick(View view) {St…
阅读更多...
看Threejs好玩示例，学习创新与技术(ProjectTexture合集)

看Threejs好玩示例，学习创新与技术(ProjectTexture合集)

本文是一个合集，稍微对ProjectTexture的技术进行总结，突出关键和创意。 演示视频如下(Playing with Texture Projection in Three.js | Codrops (tympanus.net))： 20240909_232959 1、它的创新与用途？ 这个案例中模型方块游荡的方式像水波，鼠标放上面如棍子放在水里一样…
阅读更多...
基于python+django+vue的旅游网站系统

基于python+django+vue的旅游网站系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、SSM项目源码 系统展示 【2025最新】基于协同过滤pythondjangovue…
阅读更多...
网络（四）——HTTP协议

网络（四）——HTTP协议

文章目录 认识urlurlencode和urldecodeHTTP协议格式HTTP的方法HTTP的状态码HTTP常见Header 虽然应用层的协议是由人为规定的&#xff0c;但是已经有大佬们定义了一些现成的&#xff0c;又非常好用的应用层协议&#xff0c;供我们直接参考使用. HTTP(超文本传输协议)就是其中之一…
阅读更多...
【PCB工艺】如何实现PCB板层间的互连

【PCB工艺】如何实现PCB板层间的互连

系列文章目录 1.元件基础 2.电路设计 3.PCB设计 4.元件焊接 5.板子调试 6.程序设计 7.算法学习 8.编写exe 9.检测标准 10.项目举例 11.职业规划 文章目录 前言①、什么是通孔②、通孔是怎样产生的③、通孔种类④、盘中孔⑤、设计建议 前言 送给大学毕业后找不到奋斗方向的你…
阅读更多...
AWS 将 OpenSearch 纳入 Linux 基金会旗下

AWS 将 OpenSearch 纳入 Linux 基金会旗下

AWS 今天宣布&#xff0c;随着OpenSearch 基金会的成立&#xff0c;它将把OpenSearch&#xff08;流行的 Elasticsearch 搜索和分析引擎的开源分叉&#xff09;移交给 Linux 基金会。在 Elastic 将其 Elasticsearch 和 Kibana 项目的许可证更改为自己的专有许可证 Elastic Lice…
阅读更多...
力扣题解1184

力扣题解1184

大家好&#xff0c;欢迎来到无限大的频道。 今日继续给大家带来力扣题解。 题目描述&#xff08;简单&#xff09;&#xff1a; 公交站间的距离 环形公交路线上有 n 个站&#xff0c;按次序从 0 到 n - 1 进行编号。我们已知每一对相邻公交站之间的距离&#xff0c;distanc…
阅读更多...
Vue3+Element Plus：使用el-dialog，对话框可拖动，且对话框弹出时仍然能够在背景页（对话框外部的页面部分）上进行滚动以及输入框输入信息

Vue3+Element Plus：使用el-dialog，对话框可拖动，且对话框弹出时仍然能够在背景页（对话框外部的页面部分）上进行滚动以及输入框输入信息

【需求】 使用Element Plus中的el-dialog默认是模态的&#xff08;即它会阻止用户与对话框外部的元素进行交互&#xff09;&#xff0c;对话框弹出时仍然能够在背景页&#xff08;对话框外部的页面部分&#xff09;上进行滚动以及输入框输入信息&#xff0c;且对话框可拖动 【…
阅读更多...
卷积——入门理解

卷积——入门理解

一、卷积的通俗理解 卷积的意义——通俗易懂的理解&#xff08;以吃馒头为例&#xff09; 二、 卷积的深入理解 1、卷积能解决什么问题 可以用来计算拥有记忆系统的输出问题 无记忆&#xff1a;当前的输出仅取决于当前的输入&#xff0c;而与之前的输入无关 例如&#xff1…
阅读更多...
SpringMVC1~~~

SpringMVC1~~~

快速入门 spring容器文件 在src下就是applicationContext-mvc.xml&#xff0c;需要在web.xml指定<init-param>&#xff0c;给DispatcherServlet指定要去操作的spring容器文件 在WEB-INF下就是xxx-servlet.xml&#xff0c;不需要在web.xml指定<init-param>,如果我们…
阅读更多...
Zookeeper工作机制和特点

Zookeeper工作机制和特点

1. Zookeeper工作机制 Zookeeper从设计模式角度来理解&#xff1a; 是一个基于观察者模式设计的分布式服务管理框架&#xff0c;它负责存储和管理大家都关心的数据&#xff0c;然后接受观察者的 注册&#xff0c;一旦这些数据的状态发生变化&#xff0c;Zookeeper就将负责通知…
阅读更多...
xml重点笔记(尚学堂 3h)

xml重点笔记(尚学堂 3h)

XML:可扩展标记语言 主要内容(了解即可) 1.XML介绍 2.DTD 3.XSD 4.DOM解析 6.SAX解析 学习目标 一. XML介绍 1.简介 XML(Extensible Markup Language) 可扩展标记语言&#xff0c;严格区分大小写 2.XML和HTML XML是用来传输和存储数据的。 XML多用在框架的配置文件…
阅读更多...
基于Python DoIPClient库的DoIP上位机开发手顺

基于Python DoIPClient库的DoIP上位机开发手顺

代码 address, announcement DoIPClient.await_vehicle_announcement()logical_address announcement.logical_addressip, port addressprint(ip, port, logical_address) 效果 代码 address, announcement DoIPClient.get_entity(ecu_ip_addresssIp, protocol_version3…
阅读更多...
【VitualBox】VitualBox的网络模式+网络配置

【VitualBox】VitualBox的网络模式+网络配置

VirtualBox 1. 简介 VirtualBox 是一款开源虚拟机软件&#xff0c;使用者可以在VirtualBox上安装并且执行Solaris、Windows、DOS、Linux、OS/2 Warp、BSD等系统作为客户端操作系统。 2. 六种网络接入模式 VirtualBox提供了多种网络接入模式&#xff0c;他们各有优缺点&#xf…
阅读更多...
Setting Design Properties

Setting Design Properties

设置设计属性 接下来&#xff0c;在设计上设置配置模式。这是导致物理 约束&#xff0c;在这种情况下是设计的属性&#xff0c;而不是单元的属性。首先&#xff0c;列出所有 当前设计的特性。 1.在Tcl控制台中列出设计的属性&#xff1a; list_property [current_design] 此命…
阅读更多...
本地安装MySQL并配置环境变量

本地安装MySQL并配置环境变量

MySQL是一个关系型数据库管理系统&#xff0c;是最流行的关系型数据库管理系统之一&#xff0c;在 WEB 应用方面&#xff0c;MySQL是最好的 RDBMS (Relational Database Management System&#xff0c;关系数据库管理系统) 应用软件之一。 本地安装MySQL 提供了 MySQ…
阅读更多...
mysql笔记8(多表查询)

mysql笔记8(多表查询)

文章目录 1. union联合查询可能会用到去重操作 2. inner join 内连接3. left join 左连接4. right join 右连接5. cross join 交叉连接6. natural join 自然连接natural left join 自然左连接natural right join 自然右连接自然连接的两张表没有同名字段怎么办&#xff1f; 7. …
阅读更多...
LLMs之SWIFT：SWIFT的简介、安装和使用方法、案例应用之详细攻略

LLMs之SWIFT：SWIFT的简介、安装和使用方法、案例应用之详细攻略

LLMs之SWIFT&#xff1a;SWIFT的简介、安装和使用方法、案例应用之详细攻略 目录 SWIFT的简介 新闻 &#x1f6e0;️ 安装 &#x1f680; 快速开始 Web-UI 训练 训练脚本 支持的训练过程 单卡训练 模型并行训练 数据并行训练 Deepspeed训练 多机多卡 阿里云-DLC多…
阅读更多...
棋盘格角点检测-libcbdetect

棋盘格角点检测-libcbdetect

libcbdetect libcbdetect 是一个用于自动子像素级别的棋盘格&#xff08;checkerboard&#xff09;、棋盘&#xff08;chessboard&#xff09;以及 Deltille 图案检测的库。它主要由 C 编写&#xff0c;旨在提供高精度、高鲁棒性的角点检测和图案组合功能&#xff0c;是一种基…
阅读更多...
数据中心可视化管理平台：提升运维效率

数据中心可视化管理平台：提升运维效率

通过图扑可视化平台实时监控设备状态、能耗和网络流量&#xff0c;帮助运维团队快速识别和处理异常&#xff0c;提高运营效率&#xff0c;确保系统稳定与可靠性。
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023