数据结构---二叉搜索树（二叉排序树）

news2025/1/19 17:16:33

 

什么是二叉排序树

二叉搜索树又是二叉排序树，当我们的是一颗空树或者具有以下性质时：

  1. 左子树不为空，左子树上的值都小于我们的根节点上的值。
  2. 右子树不为空时，右子树上的值都大于我们的根节点上的值
  3. 左右子树都是二叉搜索树（二叉排序树）。

我们的二叉搜索树可以支持插入想同的值，也可以不支持，这分情况的。我们的set和map是 不支持我们的插入相同的值的，但是我们的multiset和multimap 是支持可以插入相同的值的。 他们的底层是二叉搜索树

 二叉搜索树：

 性能分析

 我们的单独的二叉树，不具有某些性质的话，是没有很大的意义的，因为他的结构比较复杂。

而我们的二叉搜索树，左边是比根小的，右边是比根大的。当我们去中序遍历的时候，就可以是有序的。

  • 最优情况下，⼆叉搜索树为完全⼆叉树(或者接近完全⼆叉树)，其⾼度为：O(log2 N)、
  • 最差情况下，⼆叉搜索树退化为单⽀树(或者类似单⽀)，其⾼度为：O(log2 N ) 
  •  所以综合⽽⾔⼆叉搜索树增删查改时间复杂度为：O(N)

我们的二叉搜索树很受我们的插入的顺序影响，当那个我们的插入顺序不一样，我们的二叉搜索树的结构也是不一样的。 

这个明显是不能满足的我们的需求的，而平衡⼆ 叉搜索树AVL树和红⿊树，才能适⽤于我们在内存中存储和搜索数据。

我们的二分查找也可以实现我们的logN级别的查找效率，但是它是由条件的，

  • 他必须是在有序的情况下
  • 其次他要满足 随机访问，如果你所使用的容器不支持随机访问，是不可以使用我们的二分查找的

 当我们的二叉搜索树的值都在一段时就会严重影响我们的搜索效率。如果我们是使用递归可能会导致栈溢出的分险。

 二叉搜索树的实现

我们的每一个节点我们可以用一个类来分装一下，

我们的二叉搜索树，这个类里面用另一个类来封装起来，里面的成员变量就是我们的根节点。

用模板的话 可以让我们存的数据类型多样。

//节点
   template<class K>
	struct BSTNode
	{
		K _key;
		BSTNode<K>* _left;
		BSTNode<K>* _right;

		BSTNode(const K& key)
			:_key(key)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};
  // Binary Search Tree
	// Key
	template<class K>
	class BSTree
	{
		//typedef BSTNode<K> Node;
		using Node = BSTNode<K>;
    private:
  		Node* _root = nullptr;
	};

插入

  1. 树为空，则直接新增结点，赋值给root指针、
  2.  树不空，按⼆叉搜索树性质，插⼊值⽐当前结点⼤往右⾛，插⼊值⽐当前结点⼩往左⾛，找到空位 置，插⼊新结点。
  3.  如果⽀持插⼊相等的值，插⼊值跟当前结点相等的值可以往右⾛，也可以往左⾛，找到空位置，插 ⼊新结点。（要注意的是要保持逻辑⼀致性，插⼊相等的值不要⼀会往右⾛，⼀会往左⾛。

例子：当我们么插入这个数组里面的元素时： int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

 

我们直接利用循环来处理，当时我们再走的时候，找到空节点的时候，还需要我们知道我们的父亲节点在哪。这样我们才能连接起来。，

代码：

        bool Insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

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

			return true;
		}

删除（难点）

⾸先查找元素是否在⼆叉搜索树中，如果不存在，则返回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左⼦树的值最⼤结点 R(最右结点)或者N右⼦树的值最⼩结点R(最左结点)替代N，因为这两个结点中任意⼀个，放到N的 位置，都满⾜⼆叉搜索树的规则。替代N的意思就是N和R的两个结点的值交换，转⽽变成删除R结 点，R结点符合情况2或情况3，可以直接删除。

 代码：

bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除
					// 左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;

					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							// 右为空
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;

					}
					else
					{
						// 左右都不为空
						// 右子树最左节点
						Node* replaceParent = cur;
						Node* replace = cur->_right;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}

						cur->_key = replace->_key;

						if (replaceParent->_left == replace)
							replaceParent->_left = replace->_right;
						else
							replaceParent->_right = replace->_right;

						delete replace;
					}

					return true;
				}
			}

			return false;
		}

虽然我们在找替换的节点的时候一直在往一边走，但是我们人就要后面的判断

if (replaceParent->_left == replace)
           replaceParent->_left = replace->_right;
 else
           replaceParent->_right = replace->_right;

因为有一种情况是不满足的需要我们去进行判断；而且我们的replaceParent也不能再初始化的时候给nullptr,

查找

  1. 从根开始⽐较，查找x，x⽐根的值⼤则往右边⾛查找，x⽐根值⼩则往左边⾛查找。
  2.  最多查找⾼度次，⾛到到空，还没找到，这个值不存在。
  3.  如果不⽀持插⼊相等的值，找到x即可返回
  4.  如果⽀持插⼊相等的值，意味着有多个x存在，⼀般要求查找中序的第⼀个x。如下图，查找3，要 找到1的右孩⼦的那个3返回

代码：

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

			return false;
		}

赋值拷贝

我们的这里的拷贝也是要进行深拷贝的。

代码：

        BSTree(const BSTree& t)
		{
			_root = Copy(t._root);
		}
   private：
        Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;

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

析构

我们对于内置类型的，的确是不需要我们去写析构，但是我们这里是一个模板，里面存放的数据类型不止有我们的内置类型的，也会有我们的自定义类型，而且我们这里节点的空间都是动态申请的。

我们通过自己写一个Destory的函数去帮助我们释放空间，因为我们释放空间，也需要我们去利用递归，并需要访问我们的root，在类外不能访问我们的root，所以不好传参数，在要我们的析构去调用。

代码：

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


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

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

中序遍历

对于我们的中序遍历我们不能在类外访问我们的root，所以需要我们去写一个已经在类内实现的中序遍历_Inorder，我们再用Inorder里面调用这个函数，利用我们的封装的思想，我们的中序遍历可以实现有序。

代码：

        void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

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

 完整的实现代码

template<class K>
	struct BSTNode
	{
		K _key;
		BSTNode<K>* _left;
		BSTNode<K>* _right;

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

	// Binary Search Tree
	// Key
	template<class K>
	class BSTree
	{
		//typedef BSTNode<K> Node;
		using Node = BSTNode<K>;
	public:

		bool Insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

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

			return true;
		}

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

			return false;
		}

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除
					// 左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;

					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							// 右为空
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;

					}
					else
					{
						// 左右都不为空
						// 右子树最左节点
						Node* replaceParent = cur;
						Node* replace = cur->_right;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}

						cur->_key = replace->_key;

						if (replaceParent->_left == replace)
							replaceParent->_left = replace->_right;
						else
							replaceParent->_right = replace->_right;

						delete replace;
					}

					return true;
				}
			}

			return false;
		}

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

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

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

	private:
		Node* _root = nullptr;
	};

⼆叉搜索树key和key/value使⽤场景 

key搜索场景

只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，搜索场景只需要判断 key在不在。key的搜索场景实现的⼆叉树搜索树⽀持增删查，但是不⽀持修改，修改key破坏搜索树结 构了。也就是在不在的问题。

  1. 场景1：⼩区⽆⼈值守⻋库，⼩区⻋库买了⻋位的业主⻋才能进⼩区，那么物业会把买了⻋位的业主的 ⻋牌号录⼊后台系统，⻋辆进⼊时扫描⻋牌在不在系统中，在则抬杆，不在则提⽰⾮本⼩区⻋辆，⽆ 法进⼊。
  2. 场景2：检查⼀篇英⽂⽂章单词拼写是否正确，将词库中所有单词放⼊⼆叉搜索树，读取⽂章中的单 词，查找是否在⼆叉搜索树中，不在则波浪线标红提⽰。

key/value搜索场景：

 每⼀个关键码key，都有与之对应的值value，value可以任意类型对象。树的结构中(结点)除了需要存 储key还要存储对应的value，增/删/查还是以key为关键字⾛⼆叉搜索树的规则进⾏⽐较，可以快速查 找到key对应的value。key/value的搜索场景实现的⼆叉树搜索树⽀持修改，但是不⽀持修改key，修 改key破坏搜索树结构了，可以修改value。

  1.  场景1：简单中英互译字典，树的结构中(结点)存储key(英⽂)和vlaue(中⽂)，搜索时输⼊英⽂，则同时 查找到了英⽂对应的中⽂。
  2. 场景2：商场⽆⼈值守⻋库，⼊⼝进场时扫描⻋牌，记录⻋牌和⼊场时间，出⼝离场时，扫描⻋牌，查 找⼊场时间，⽤当前时间-⼊场时间计算出停⻋时⻓，计算出停⻋费⽤，缴费后抬杆，⻋辆离场。
  3. 场景3：统计⼀篇⽂章中单词出现的次数，读取⼀个单词，查找单词是否存在，不存在这个说明第⼀次 出现，（单词，1），单词存在，则++单词对应的次数。

我们的额key的情况和key、value的代码基本一样。

代码：

template<class K, class V>
	struct BSTNode
	{
		K _key;
		V _value;

		BSTNode<K, V>* _left;
		BSTNode<K, V>* _right;

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

	// Binary Search Tree
	// Key/value
	template<class K, class V>
	class BSTree
	{
		//typedef BSTNode<K> Node;
		using Node = BSTNode<K, V>;
	public:
		// 强制生成构造
		BSTree() = default;

		BSTree(const BSTree& t)
		{
			_root = Copy(t._root);
		}

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

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

		bool Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

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

			return true;
		}

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

			return nullptr;
		}

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除
					// 左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;

					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							// 右为空
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;

					}
					else
					{
						// 左右都不为空
						// 右子树最左节点
						Node* replaceParent = cur;
						Node* replace = cur->_right;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}

						cur->_key = replace->_key;

						if (replaceParent->_left == replace)
							replaceParent->_left = replace->_right;
						else
							replaceParent->_right = replace->_right;

						delete replace;
					}

					return true;
				}
			}

			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

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

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

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

		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;

			Node* newRoot = new Node(root->_key, root->_value);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}
	private:
		Node* _root = nullptr;
	};

 

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

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

相关文章

我的AI工具箱Tauri版-VideoDuplication视频素材去重

我的AI工具箱Tauri版-VideoDuplication视频素材去重

本教程基于自研的AI工具箱Tauri版进行VideoDuplication视频素材去重。 该项目是基于自研的AI工具箱Tauri版的视频素材去重工具&#xff0c;用于高效地处理和去除重复视频内容。用户可以通过搜索关键词"去重"或通过路径导航到"Python音频技术/视频tools"模…
阅读更多...
封装的例题

封装的例题

答案A 解析&#xff1a; 选项B说法也正确&#xff0c;但是不如A更有效 选项C 不管采用什么方法&#xff0c;文档是必须要写的 选项D 说法太绝对了&#xff0c;如果封装的内容不适合&#xff0c;开发者可能做软件开发反而难度系数加大
阅读更多...
芯片开发（1）---BQ76905---底层参数配置

芯片开发（1）---BQ76905---底层参数配置

主要开发思路:AFE主要是采集、保护功能、均衡&#xff0c;所以要逐一去配置芯片的寄存器 采集、均衡功能主要是配置引脚 保护功能主要是参数寄存器配置&#xff0c;至于如何使用命令修改寄存器参数该系列芯片提供了子命令和直接命令两种方式 BQ76905的管脚配置 I、参数配置 …
阅读更多...
ubuntu 执行定时任务crontab -e 无法输入的问题

ubuntu 执行定时任务crontab -e 无法输入的问题

界面显示 GNU nano 4.8 /tmp/crontab.l0A1HJ/crontab # Edit this file to introduce tasks to be run by cron. # # Each task to run has to be defined t…
阅读更多...
全国职业院校技能大赛（大数据赛项）-平台搭建hive笔记

全国职业院校技能大赛（大数据赛项）-平台搭建hive笔记

在大数据时代&#xff0c;数据量呈爆炸性增长&#xff0c;传统的数据处理工具已难以满足需求。Hive作为一个开源的数据仓库工具&#xff0c;能够处理大规模数据集&#xff0c;提供了强大的数据查询和分析能力&#xff0c;是大数据学习中的关键工具。在全国职业院校技能大赛&…
阅读更多...
【图像检索】基于Gabor特征的图像检索，matlab实现

【图像检索】基于Gabor特征的图像检索，matlab实现

博主简介&#xff1a;matlab图像代码项目合作&#xff08;扣扣&#xff1a;3249726188&#xff09; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 本次案例是基于Gabor特征的图像检索&#xff0c;用matlab实现。 一、案例背景和算法介绍 这次博…
阅读更多...
GPT-4o在matlab编程中性能较好，与智谱清言相比

GPT-4o在matlab编程中性能较好，与智谱清言相比

边标签由矩阵给出 s [1 2 3 3 3 3 4 5 6 7 8 9 9 9 10]; t [7 6 1 5 6 8 2 4 4 3 7 1 6 8 2]; G graph(s,t); plot(G) ------------------- GPT-4o给出的代码可用&#xff0c; clc;clear; % 定义边的起点和终点 s [1 2 3 3 3 3 4 5 6 7 8 9 9 9 10]; t [7 6 1 5 6 8 2 …
阅读更多...
您可能一直在寻找的 10 个非常有用的前端库

您可能一直在寻找的 10 个非常有用的前端库

文章目录 前言正文1.radash2.dayjs3.driver4.formkit/drag-and-drop5.logicflow6.ProgressBar7.tesseract8.zxcvbn9.sunshine-track10.lottie 前言 前端开发中&#xff0c;总有一些重复性的工作让我们疲于奔命。为了提高开发效率&#xff0c;我们精心挑选了10个功能强大、易于…
阅读更多...
【油猴脚本】00010 案例 Tampermonkey油猴脚本，动态渲染表格-添加提示信息框,HTML+Css+JavaScript编写

【油猴脚本】00010 案例 Tampermonkey油猴脚本，动态渲染表格-添加提示信息框,HTML+Css+JavaScript编写

前言&#xff1a;哈喽&#xff0c;大家好&#xff0c;今天给大家分享一篇文章&#xff01;并提供具体代码帮助大家深入理解&#xff0c;彻底掌握&#xff01;创作不易&#xff0c;如果能帮助到大家或者给大家一些灵感和启发&#xff0c;欢迎收藏关注哦 &#x1f495; 目录 【油…
阅读更多...
Ubuntu 22.04 源码下载、编译

Ubuntu 22.04 源码下载、编译

Kernel/BuildYourOwnKernel - Ubuntu Wikihttps://wiki.ubuntu.com/Kernel/BuildYourOwnKernel 一、查询当前系统内核版本 rootubuntu22:~# uname -r 5.15.0-118-generic 二、查询本地软件包数据库中的内核源码信息 rootubuntu22:~# apt search linux-source Sorting... Do…
阅读更多...
Unity实现原始的发射子弹效果

Unity实现原始的发射子弹效果

1 创建一个炮塔&#xff0c;按下空格-坦克会发射一个小球2.小球会掉在地上滚下来-添加组件3 间隔几秒后自动销毁程序逻辑&#xff1a;1.在场景中创建一个炮塔\子弹拿到代码里的变量里程序逻辑&#xff1a; 2.if语句检测用户有没有按下空格程序逻辑&#xff1a; 3.在炮塔坐标的位…
阅读更多...
5. 数字证书与公钥基础设施

5. 数字证书与公钥基础设施

5. 数字证书与公钥基础设施 (1) PKI 的定义、组成及应用 PKI（Public Key Infrastructure，公钥基础设施） 是一个使用公钥技术来提供安全服务的框架。它定义了如何管理和维护公钥，以及如何通过证书来验证公钥的真实性。PKI的核心组成部分包括： 证书颁发机构（CA, Certifica…
阅读更多...
(done) 声音信号处理基础知识(4) (Understanding Audio Signals for ML)

(done) 声音信号处理基础知识(4) (Understanding Audio Signals for ML)

来源&#xff1a;https://www.youtube.com/watch?vdaB9naGBVv4 模拟信号特点如下 时域连续(x轴) 振幅连续(y轴) 如下是模拟信号的一个例子&#xff1a; 数字信号特点如下&#xff1a; 一个离散值序列 数据点的值域是一系列有限的值 ADC&#xff1a;模拟信号到数字信号的…
阅读更多...
Elionix 电子束曝光系统

Elionix 电子束曝光系统

Elionix 电子束曝光系统 - 上海纳腾仪器有限公司 -
阅读更多...
Python包、模块、库辨析

Python包、模块、库辨析

目录 1 模块的基础介绍 2 包的概念解析 3 库的定义与作用 4 区分三者 5 实例 __init__.py addition.py multiplication.py main_scipt 1 模块的基础介绍 模块是 Python 编程的基本组成部分之一&#xff0c;它是单个文件 &#xff0c;包含 Python 代码&#xff0c;可以定…
阅读更多...
GB28181协议接入SVMSPro平台

GB28181协议接入SVMSPro平台

国标28181协议接入SVMSPro平台 步骤一&#xff1a;海康摄像机28181配置&#xff1b;登录海康摄像机网页进配置选项&#xff0c;左边选网络-高级设置-平台接入-类型选28181 勾选启用&#xff0c;28181协议版本选最新2016 SIP服务器ID:默认20位 34020000002000000001,也可在服务端…
阅读更多...
Linux系统网络诊断工具MTR使用方法

Linux系统网络诊断工具MTR使用方法

我们一般做linux系统服务器测评的时候&#xff0c;基本都会进行网速方面的测试&#xff0c;这方面的脚本工具啥的有很多&#xff0c;其中MTR是Linux平台上一款非常好用的网络诊断工具&#xff0c;集成了traceroute、ping、nslookup的功能&#xff0c;用于诊断网络状态非常有用。…
阅读更多...
胤娲科技：谷歌DeepMind祭出蛋白质设计新AI——癌症治疗迎来曙光

胤娲科技：谷歌DeepMind祭出蛋白质设计新AI——癌症治疗迎来曙光

在科技的浩瀚星空中&#xff0c;DeepMind的“阿尔法”家族总是能带来令人瞩目的璀璨光芒。这一次&#xff0c;它们再次以惊人的姿态&#xff0c; 将AI的触角深入到了生命的微观世界——蛋白质设计领域&#xff0c;为我们描绘了一幅未来医疗的宏伟蓝图。 想象一下&#xff0c;一…
阅读更多...
思通数科开源产品：免费的AI视频监控卫士安装指南

思通数科开源产品：免费的AI视频监控卫士安装指南

准备运行环境&#xff1a; 确保您的服务器或计算机安装了Ubuntu 18.04 LTS操作系统。 按照产品要求&#xff0c;安装以下软件&#xff1a; - Python 3.9 - Java JDK 1.8 - MySQL 5.5 - Redis 2.7 - Elasticsearch 8.14 - FFmpeg 4.1.1 - RabbitMQ 3.13.2 - Minio &#xff08;…
阅读更多...
网络丢包定位记录(三)

网络丢包定位记录(三)

网络IP层丢包 接口ip地址配置丢包 1. 本机服务不通&#xff0c;检查lo接口有没有配置地址是127.0.0.1&#xff1b; 2 .本机接收失败&#xff0c; 查看local路由表&#xff1a;ip r show table local|grep 子机ip地址&#xff1b;这种丢包一般会出现在多IP场景&#xff0c;子…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023