【C++ 第十二章】二叉搜索树

news2024/12/22 19:18:31

1.1 二叉搜索树概念


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

  • 左边小：若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 右边大：若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树

1.2 二叉搜索树操作

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

0. 二叉搜索树节点的创建 与 基础框架的构建

节点类

template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;

	K _key;
	Node* _left;
	Node* _right;

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

基础框架

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;

public:


private:
	Node* _root = nullptr;
};

1. 二叉搜索树的查找  find


a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。

// 1、查找
bool Find(const K& val) {
	if (_root == nullptr) {
		return false;
	}

	Node* cur = _root;
	while (cur) {
		if (cur->_key > val) {
			cur = cur->_left;
		}
		else if (cur->_key < val) {
			cur = cur->_right;
		}
		else return true;
	}

	return false;
}

 
2. 二叉搜索树的插入  insert


插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给 root 指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

Node* Insert(const K& val) {
	// （1）先判断节点是否存在
	if (Find(val)) {
		cout << "结点已存在" << '\n';
		return _root;
	}
	// （2）如果根为空，则直接插入一个节点
	if (_root == nullptr) {
		_root = new Node(val);
		return _root;
	}

	// （3）按照二叉搜索树的性质，走到合适的位置
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur) {
		if (cur->_key > val) {
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < val) {
			parent = cur;
			cur = cur->_right;
		}
	}

	// （4）插入节点：和父节点链接上
	cur = new Node(val);
	if (parent->_key > val) {
		parent->_left = cur;
	}
	else if (parent->_key < val) {
		parent->_right = cur;
	}

	return _root;
}

3. 二叉搜索树的删除

代码逻辑：

（1）先判断该节点是否存在：如果不存在，则返回

（2）按照搜索树的规则，找到目标节点位置

（3）分情况执行删除操作：

要删除的结点可能分下面四种情况：

a. 要删除的结点无孩子结点：没有孩子

b. 要删除的结点只有左孩子结点：只有 左孩子

c. 要删除的结点只有右孩子结点：只有 右孩子

d. 要删除的结点有左、右孩子结点：有左右孩子

看起来有待删除节点有 4 种情况，实际情况 a 可以与情况 b 或者 c 合并起来

因此真正的删除过程 如下：

⭐有一个孩子 或 零个孩子：

  • 情况1：删除该节点，使该节点的 父亲 指向 该节点的左孩子
  • 情况2：删除该节点，使该节点的 父亲 指向 该节点的右孩子

⭐有两个孩子：

  • 情况 3：替换法（删掉一个节点，可以找一个继承人继承你当前的位置）

你当前的位置有个特征：左边节点一定比你小，右边节点一定比你大

因此，你找的继承人一定也要满足这个条件：即可以是 左子树的最大节点 或 右子树的最小节点

  • 左子树的最大节点：一定比左子树的根要大，一定比右子树的根要小
  • 右子树的最小节点：一定比左子树的根要大，一定比右子树的根要小

替换规则：

        直接将要删除的节点的键值key 替换成 继承人的键值key，然后删除继承人（因为继承人一定是叶子节点，可以直接删除，不用处理是否有孩子的问题）

替换法 使得删除节点变得简单，而便利

代码中有详细的 步骤解释了

// 3、删除
void Erase(const K& val) {
	// （1）先看节点是否存在
	if (!Find(val)) {
		cout << "结点不存在" << '\n';
		return;
	}

	// （2）按照搜索树的规则，找到目标节点位置
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur) {
		if (cur->_key > val) {
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < val) {
			parent = cur;
			cur = cur->_right;
		}
		else break;
	}

	// （3）分情况执行删除操作：
	// 0~1个孩子：删除该节点后，让父节点指向我的孩子
	if (cur->_right == nullptr) {

		// 特殊情况：当父亲为空时，证明当前要删除的节点是根，直接删除，让根指针指向孩子
		if (parent == nullptr) {
			_root = cur->_left;
		}
		else {
			if (parent->_key > cur->_key) {
				parent->_left = cur->_left;
			}
			else if (parent->_key < cur->_key) {
				parent->_right = cur->_left;
			}
		}
		delete cur;
	}
	else if (cur->_left == nullptr) {
		if (parent == nullptr) {
			_root = cur->_right;
		}
		else {
			if (parent->_key > cur->_key) {
				parent->_left = cur->_right;
			}
			else if (parent->_key < cur->_key) {
				parent->_right = cur->_right;
			}
		}
		delete cur;
	}


	// 2 个孩子 及以上：替换法
	// 我们这里继承人是 ：右子树的最左节点
	else {
		// 删除 右子树的最左节点
		Node* MinR_parent = cur;  // 右子树的最左节点的 父节点：这里一定要赋值为 cur，不能赋值为 nullptr
		Node* MinRight = cur->_right; // 右子树的根

		while (MinRight->_left) {
			MinR_parent = MinRight;
			MinRight = MinRight->_left;
		}

		// 继承 cur 的位置
		cur->_key = MinRight->_key;


		// 删掉继承人，同时父节点接管 cur 的右孩子（为什么一定是右孩子：因为我们本代码要删除 右子树的最左节点，因此你就是最左的节点了，不可能还存在左节点）
		// 这里的问题是：Min 不知道是 MinParent的 左孩子 or 右孩子
		if (MinR_parent->_right == MinRight) {
			MinR_parent->_right = MinRight->_right;  // 可以是 空，也可以是一个节点
		}

		else MinR_parent->_left = MinRight->_right;  // 可以是 空，也可以是一个节点
		delete MinRight;
	}
}

4. 二叉树的中序遍历（便于观察结果）

void _InorderSearch(Node* root) {
	if (root == nullptr) {
		return;
	}
	_InorderSearch(root->_left);
	cout << root->_key << ' ';
	_InorderSearch(root->_right);
}

1.3 总代码 BinarySearchTree.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;


template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;

	K _key;
	Node* _left;
	Node* _right;

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

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;

public:
	// 1、查找
	bool Find(const K& val) {
		if (_root == nullptr) {
			return false;
		}

		Node* cur = _root;
		while (cur) {
			if (cur->_key > val) {
				cur = cur->_left;
			}
			else if (cur->_key < val) {
				cur = cur->_right;
			}
			else return true;
		}

		return false;
	}
	// 2、插入
	Node* Insert(const K& val) {
		// （1）先判断节点是否存在
		if (Find(val)) {
			cout << "结点已存在" << '\n';
			return _root;
		}
		// （2）如果根为空，则直接插入一个节点
		if (_root == nullptr) {
			_root = new Node(val);
			return _root;
		}

		// （3）按照二叉搜索树的性质，走到合适的位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_key > val) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < val) {
				parent = cur;
				cur = cur->_right;
			}
		}

		// （4）插入节点：和父节点链接上
		cur = new Node(val);
		if (parent->_key > val) {
			parent->_left = cur;
		}
		else if (parent->_key < val) {
			parent->_right = cur;
		}

		return _root;
	}
	// 3、中序遍历：直接就是排序了


	void InorderSearch() {
		_InorderSearch(_root);
		cout << '\n';
	}
	// 4、删除
	void Erase(const K& val) {
		// （1）先看节点是否存在
		if (!Find(val)) {
			cout << "结点不存在" << '\n';
			return;
		}
		
		// （2）按照搜索树的规则，找到目标节点位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_key > val) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < val) {
				parent = cur;
				cur = cur->_right;
			}
			else break;
		}

		// （3）分情况执行删除操作：
		// 0~1个孩子：删除该节点后，让父节点指向我的孩子
		if (cur->_right == nullptr) {

			// 特殊情况：当父亲为空时，证明当前要删除的节点是根，直接删除，让根指针指向孩子
			if (parent == nullptr) {
				_root = cur->_left;
			}
			else {
				if (parent->_key > cur->_key) {
					parent->_left = cur->_left;
				}
				else if (parent->_key < cur->_key) {
					parent->_right = cur->_left;
				}
			}
			delete cur;
		}
		else if (cur->_left == nullptr) {
			if (parent == nullptr) {
				_root = cur->_right;
			}
			else {
				if (parent->_key > cur->_key) {
					parent->_left = cur->_right;
				}
				else if (parent->_key < cur->_key) {
					parent->_right = cur->_right;
				}
			}
			delete cur;
		}


		// 2 个孩子 及以上：替换法
		// 我们这里继承人是 ：右子树的最左节点
		else {
			// 删除 右子树的最左节点
			Node* MinR_parent = cur;  // 右子树的最左节点的 父节点：这里一定要赋值为 cur，不能赋值为 nullptr
			Node* MinRight = cur->_right; // 右子树的根

			while (MinRight->_left) {
				MinR_parent = MinRight;
				MinRight = MinRight->_left;
			}

			// 继承 cur 的位置
			cur->_key = MinRight->_key;

			
			// 删掉继承人，同时父节点接管 cur 的右孩子（为什么一定是右孩子：因为我们本代码要删除 右子树的最左节点，因此你就是最左的节点了，不可能还存在左节点）
			// 这里的问题是：Min 不知道是 MinParent的 左孩子 or 右孩子
			if (MinR_parent->_right == MinRight) {
				MinR_parent->_right = MinRight->_right;  // 可以是 空，也可以是一个节点
			}

			else MinR_parent->_left = MinRight->_right;  // 可以是 空，也可以是一个节点
			delete MinRight;
		}
	}

private:
	// 将该函数直接写成 私有
	void _InorderSearch(Node* root) {
		if (root == nullptr) {
			return;
		}
		_InorderSearch(root->_left);
		cout << root->_key << ' ';
		_InorderSearch(root->_right);
	}

	Node* _root = nullptr;
};

 

1.4 二叉搜索树的应用（Key/Value 模型的 代码）

1.4.1  两种模型

（1）K模型：K模型即只有 key 作为关键码，结构中只需要存储 Key 即可，关键码即为需要搜索到的值。

key ：在不在的场景

如门禁系统：人脸识别一对一

如检查当前写的文字中有没有错误单词：通过录入正确的词典，在词典中搜索对应的单词，若找不到，则说明该单词拼写错误

（2）KV模型：每一个关键码 key，都有与之对应的值Value，即的键值对。该种方式在现实生活中非常常见：

key / value：通过一个值找另一个值

如 字典

如 车库收费系统：按时收费

车辆驶入时，机器扫描 车牌作为 key，value 存为 进入时间

当你出门时，再次扫描车牌，匹配 key，通过当前时间和 value 的时间差，计算收费价格

1.4.2 <key, value> 模型的 代码

将节点改成 pair<key, value> 类型，即键值对模型

节点类模板

template<class K, class V>
struct BSTreeNode
{
	typedef BSTreeNode<K, V> Node;

	pair<K, V> _kv;
	Node* _left;
	Node* _right;

	BSTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

二叉搜索树类模板

template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;

public:
	// 1、查找
	bool Find(const K& val) {
		if (_root == nullptr) {
			return false;
		}

		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first > val) {
				cur = cur->_left;
			}
			else if (cur->_kv.first < val) {
				cur = cur->_right;
			}
			else return true;
		}

		return false;
	}
	// 2、插入
	Node* Insert(const pair<K, V>& data) {
		// （1）先判断节点是否存在
		if (Find(data.first)) {
			cout << "结点已存在" << '\n';
			return _root;
		}

		// （2）如果根为空，则直接插入一个节点
		if (_root == nullptr) {
			_root = new Node(data);
			return _root;
		}

		// （3）按照二叉搜索树的性质，走到合适的位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first > data.first) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < data.first) {
				parent = cur;
				cur = cur->_right;
			}
		}

		// （4）插入节点：和父节点链接上
		cur = new Node(data);
		if (parent->_kv.first > data.first) {
			parent->_left = cur;
		}
		else if (parent->_kv.first < data.first) {
			parent->_right = cur;
		}

		return _root;
	}
	// 3、中序遍历：直接就是排序了


	void InorderSearch() {
		_InorderSearch(_root);
		cout << '\n';
	}

	// 4、删除
	void Erase(const K& val) {
		// （1）先看节点是否存在
		if (!Find(val)) {
			cout << "结点不存在" << '\n';
			return;
		}

		// （2）按照搜索树的规则，找到目标节点位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first > data.first) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < data.first) {
				parent = cur;
				cur = cur->_right;
			}
			else break;
		}

		// （3）分情况执行删除操作：
		// 0~1个孩子：删除该节点后，让父节点指向我的孩子
		if (cur->_right == nullptr) {

			// 特殊情况：当父亲为空时，证明当前要删除的节点是根，直接删除，让根指针指向孩子
			if (parent == nullptr) {
				_root = cur->_left;
			}
			else {
				if (parent->_key > cur->_key) {
					parent->_left = cur->_left;
				}
				else if (parent->_key < cur->_key) {
					parent->_right = cur->_left;
				}
			}
			delete cur;
		}
		else if (cur->_left == nullptr) {
			if (parent == nullptr) {
				_root = cur->_right;
			}
			else {
				if (parent->_kv.first > data.first) {
					parent->_left = cur->_right;
				}
				else if (parent->_kv.first < data.first) {
					parent->_right = cur->_right;
				}
			}
			delete cur;
		}


		// 2 个孩子 及以上：替换法
		// 我们这里继承人是 ：右子树的最左节点
		else {
			// 删除 右子树的最左节点
			Node* MinR_parent = cur;  // 右子树的最左节点的 父节点：这里一定要赋值为 cur，不能赋值为 nullptr
			Node* MinRight = cur->_right; // 右子树的根

			while (MinRight->_left) {
				MinR_parent = MinRight;
				MinRight = MinRight->_left;
			}

			// 继承 cur 的位置
			cur->_kv.first = MinRight.first;

			// 删掉继承人，同时父节点接管 cur 的右孩子（为什么一定是右孩子：因为我们本代码要删除 右子树的最左节点，因此你就是最左的节点了，不可能还存在左节点）
			// 这里的问题是：Min 不知道是 MinParent的 左孩子 or 右孩子
			if (MinR_parent->_right == MinRight) {
				MinR_parent->_right = MinRight->_right;  // 可以是 空，也可以是一个节点
			}

			else MinR_parent->_left = MinRight->_right;  // 可以是 空，也可以是一个节点
			delete MinRight;
		}
	}

private:
	// 将该函数直接写成 私有
	void _InorderSearch(Node* root) {
		if (root == nullptr) {
			return;
		}
		_InorderSearch(root->_left);
		cout << root->_kv.first << " : " <<  root->_kv.second << '\n';
		_InorderSearch(root->_right);
	}

	Node* _root = nullptr;
};

使用测试代码：

void TestKV() {
	vector<pair<string, string>>v = { {"string", "字符串"}, {"apple", "苹果"}, {"banana", "香蕉"} };
	my::BSTree<string, string> tree;
	for (auto e : v) {
		tree.Insert(e);
	}
	tree.InorderSearch();
}

 

1.5 二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二 叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

一种是较为 平衡的结构，一种是退化成链表的结构

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：O(logn)

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：O(n)

问题：如果退化成单支树(像一条链表一样)，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？（即树的节点分布比较平衡）那么我们后续章节学习的 AVL树 和 红黑树 就可以上场了。

AVL树、红黑树 都是 平衡二叉树，使得 节点的分布平衡，使 搜索性能达到 O(logn)


 

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

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

相关文章

并网式光伏气象站——科技百科

并网式光伏气象站——科技百科

并网式光伏气象站的工作原理简洁而充满智慧&#xff0c;并网式光伏气象站巧妙地通过太阳能电池板将太阳能转化为电能&#xff0c;利用先进的气象监测设备&#xff0c;‌对风速、‌风向、‌温度、‌湿度、‌光照等关键气象要素进行实时监测和记录&#xff0c;不仅充分利用了太阳…
阅读更多...
【初阶数据结构题目】32. 希尔排序

【初阶数据结构题目】32. 希尔排序

文章目录 希尔排序希尔排序的时间复杂度计算 希尔排序 希尔排序法又称缩小增量法。希尔排序法的基本思想是&#xff1a;先选定一个整数&#xff08;通常是gap n/31&#xff09;&#xff0c;把待排序文件所有记录分成各组&#xff0c;所有的距离相等的记录分在同一组内&#x…
阅读更多...
全国10米分辨率逐年植被覆盖度（FVC）数据集

全国10米分辨率逐年植被覆盖度（FVC）数据集

本数据集包括2017至2023年间&#xff0c;全国植被覆盖度数据&#xff0c;FVC范围值为0-1&#xff0c;数据为浮点型&#xff0c;GeoTIFF格式。GeoTIFF文件均可用ArcGIS软件和GDAL读取和打开。 植被覆盖度是指植被&#xff08;包括叶、茎、枝&#xff09;在地面的垂直投影面积占统…
阅读更多...
系统编程-进程初步2

系统编程-进程初步2

进程初步2 目录 进程初步2 1、进程等待清理函数&#xff08;wait&#xff09; 2、等待指定的子进程&#xff08;waitpid&#xff09; 3、新的开辟进程的函数&#xff08;vfork&#xff09; 4、在程序中运行系统下的指令&#xff08;system&#xff09; 5、exec 函数族 …
阅读更多...
初识指针4の学习笔记

初识指针4の学习笔记

目录 1>>前言 2>>字符指针变量 3>>数组指针变量 4>>函数指针变量 5>>函数指针数组 6>>回调函数是什么&#xff1f; 7>>结语 1>>前言 今天我会继续分享一些我做的笔记&#xff0c;以及我对指针的理解&#xff0c; 后续会…
阅读更多...
查看会议所属CCF级别（A/B/C类会议）

查看会议所属CCF级别（A/B/C类会议）

步骤&#xff1a; 1、打开中国计算机学会官网&#xff1a;中国计算机学会 (ccf.org.cn)。 2、搜索框中输入会议名称&#xff0c;例如&#xff1a;SIGKDD。 3、点击打开如图所示来源是“学术评价”的网页。 4、进入如下页面。 可以看到&#xff0c;SIGKDD是CCF A类会议。 参考…
阅读更多...
低代码: 关于Test Driven Development - 测试驱动开发组件与测试示例

低代码: 关于Test Driven Development - 测试驱动开发组件与测试示例

TDD 的开发方式 Test Driven Development - 测试驱动开发这是一种非常有意思的开发方式，我们进入一个实际场景，拿需要自研的colorpicker表单组件来说表单中的很多属性，都需要进行一个颜色的选择，如背景颜色，字体颜色等等我们来看一下相关设计交互在这里我们分两个图，点击…
阅读更多...
python的导入包飘红

python的导入包飘红

本文是mac的解决方法 1、点击pycharm-preferences-paython interpreter 直接搜索你要导入的包名&#xff0c;选择版本号点击 install 2、第二种方法是命令 pip3 install pandas2.2.2
阅读更多...
学习文件IO，让你从操作系统内核的角度去理解输入和输出（理论篇）

学习文件IO，让你从操作系统内核的角度去理解输入和输出（理论篇）

本篇会加入个人的所谓鱼式疯言 ❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言 而是理解过并总结出来通俗易懂的大白话, 小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的. &#x1f92d;&#x1f92d;&#x1f92d;可能说的不是那么严谨.但小编初心是能让更多人…
阅读更多...
day06——前后端交互

day06——前后端交互

一、计算属性 计算属性就是基于现有的数据推算出来的新属性&#xff0c;只要依赖的数据变化&#xff0c;新属性就会自动更新&#xff0c;而且计算属性多次调用的情况下只会计算一次&#xff0c;效率非常高 简化写法 const app new Vue({ el: #app, data: {}, methods: {//跟da…
阅读更多...
易境通海运系统：打造海运专线稳定合作的强力引擎

易境通海运系统：打造海运专线稳定合作的强力引擎

对于海运专线而言&#xff0c;稳定的合作伙伴至关重要。在激烈的市场竞争中&#xff0c;如何持续保持客户的高满意度&#xff0c;不断强化自身优势&#xff0c;并提升用户粘性&#xff0c;是众多海运专线必须面对并解决的问题。而拥有一套可靠的系统&#xff0c;提供完备的服务…
阅读更多...
会“坐”电梯，能避障碍，AGV无人搬运车进入各行各业

会“坐”电梯，能避障碍，AGV无人搬运车进入各行各业

AGV 近年来&#xff0c;自动导引车&#xff08;Automated Guided Vehicle&#xff0c;简称AGV&#xff09;作为一种先进的物流设备&#xff0c;在制造业中广泛应用。AGV是一种能够自主行驶的无人驾驶车辆&#xff0c;通过内置的导航系统和传感器&#xff0c;实现对环境的感知与…
阅读更多...
Loop Map 循环的几种方法

Loop Map 循环的几种方法

参考 Using entrySet() public void iterateUsingEntrySet(Map<String, Integer> map) {for (Map.Entry<String, Integer> entry : map.entrySet()) {System.out.println(entry.getKey() ":" entry.getValue());} } Iterator<Map.Entry<String…
阅读更多...
Apache CloudStack Official Document 翻译节选（七）

Apache CloudStack Official Document 翻译节选（七）

关于 Apache CloudStack 的 最佳实践 &#xff08;一&#xff09; Best Practices 部署Apache CloudStack是极具挑战性的&#xff0c;在整个部署过程中需要你做出形形色色的技术性选择。Apache CloudStack的配置条目是相当灵活的&#xff0c;这是因为在组合和配置具体条目时有…
阅读更多...
手机谷歌浏览器怎么用

手机谷歌浏览器怎么用

谷歌浏览器不仅在PC端受欢迎&#xff0c;在移动端也是广泛应用的。为了帮助大家更好的理解和使用手机谷歌浏览器&#xff0c;本文将详细介绍如何使用手机谷歌浏览器&#xff0c;对这款浏览器感到陌生的话就快快学起来吧。&#xff08;本文由https://chrome.cmrrs.com/站点的作者…
阅读更多...
动手学深度学习7.6 残差网络（ResNet）-笔记练习（PyTorch）

动手学深度学习7.6 残差网络（ResNet）-笔记练习（PyTorch）

本节课程地址&#xff1a;29 残差网络 ResNet【动手学深度学习v2】_哔哩哔哩_bilibili 29.2 ResNet为什么能训练出1000层的模型【动手学深度学习v2】_哔哩哔哩_bilibili 本节教材地址&#xff1a;7.6. 残差网络&#xff08;ResNet&#xff09; — 动手学深度学习 2.0.0 docume…
阅读更多...
制造企业MES系统质检管理的应用

制造企业MES系统质检管理的应用

MES系统在质检管理中的作用 MES系统通过集成生产过程中的各个环节&#xff0c;实现对产品质量的全面监控和管理。其在质检管理中的作用主要体现在以下几个方面&#xff1a; 1. 实时数据采集&#xff1a;MES系统能够实时收集生产线上的质量数据&#xff0c;包括但不限于产品尺…
阅读更多...
知识改变命运 数据结构【栈和队列面试题】

知识改变命运 数据结构【栈和队列面试题】

1.最小栈 class MinStack {Stack <Integer>stack;Stack <Integer>minStack; public MinStack() {stacknew Stack<>();minStacknew Stack<>();}public void push(int val) {stack.push(val);if(minStack.empty()) {minStack.push(val);} else {int top…
阅读更多...
汇昌联信科技做拼多多电商怎么提升浏览量？

汇昌联信科技做拼多多电商怎么提升浏览量？

随着电子商务的蓬勃发展&#xff0c;各大平台之间的竞争变得日益激烈。在这样的背景下&#xff0c;汇昌联信科技如何通过有效的策略来提升其在拼多多平台上的店铺浏览量&#xff0c;成为了一个值得深入探讨的问题。提升浏览量不仅能够增加商品的曝光率&#xff0c;还能有效提高…
阅读更多...
【设计模式】六大原则-下

【设计模式】六大原则-下

❓首先什么是设计模式&#xff1f; &#x1f635;相信刚上大学的你和我一样&#xff0c;在学习这门课的时候根本不了解这些设计原则和模式有什么用处&#xff0c;反而不如隔壁的C更有意思&#xff0c;至少还能弹出一个小黑框&#xff0c;给我个hello world。 ✨ 如何你和我一样…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023