【C++庖丁解牛】二叉搜索树（Binary Search Tree，BST）

news2024/11/15 12:12:23
🍁你好，我是 RO-BERRY
📗 致力于C、C++、数据结构、TCP/IP、数据库等等一系列知识
🎄感谢你的陪伴与支持 ，故事既有了开头，就要画上一个完美的句号，让我们一起加油

在这里插入图片描述

目录

  • 1. 二叉搜索树概念
  • 2. 二叉搜索树操作
  • 3. 二叉搜索树的实现
    • 3.1 准备工作
      • 结点结构体BSTreeNode
      • 二叉搜索树BinarySearchTree
    • 3.2 函数体实现
      • 📖bool Insert(const K& key)
      • 📖bool Find(const K& key)
      • 📖打印二叉搜索树void InOrder()
      • 📖删除 Erase
      • 📖构造函数、析构函数、拷贝构造以及复制拷贝
    • 3.3 函数体实现(优化版)
      • 📖优化版insert函数
      • 📖优化版find函数
      • 📖优化版Erase函数
    • 3.4 源代码BinarySearchTree.h
  • 4. 二叉搜索树的应用
    • kv二叉树实现
  • 5. 二叉搜索树的性能分析

1. 二叉搜索树概念

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

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

二叉搜索树（Binary Search Tree，简称BST）是种常用的数据结构，它是一棵二叉树，并且满足以下性质：

对任意节点，其左子树中的节点的值都小于该节点的值。
对于任意节点，其右子树中的所有节点的值都大于该节点的值。
左子树和右子树也都是二叉搜索树。
二叉搜索树的这种特性使得它在查找、插入和删除操作上具有高效性能。通过比较节点的值，可以快速定位到目标节点或者确定插入位置。

二叉搜索树的操作包括：

查找：从根节点开始，递归地比较目标值与当前节点的值，直到找到目标节点或者遍历到叶子节点。
插入：从根节点开始，递归地比较目标值与当前节点的值，根据大小关系选择左子树或右子树进行插入，直到找到合适的插入位置。
删除：删除操作比较复杂，需要考虑被删除节点的子节点情况。可以分为三种情况：被删除节点没有子节点、被删除节点只有一个子节点、被删除节点有两个子节点。
二叉搜索树的时间复杂度取决于树的高度，平均情况下为O(log n)，最坏情况下为O(n)。为了保持树的平衡，可以使用平衡二叉搜索树（如AVL树、红黑树）来优化性能。

在这里插入图片描述

2. 二叉搜索树操作

在这里插入图片描述

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};
  1. 二叉搜索树的查找
    a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
    b、最多查找高度次，走到到空，还没找到，这个值不存在。
  2. 二叉搜索树的插入
    插入的具体过程如下：
    a. 树为空，则直接新增节点，赋值给root指针
    b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

在这里插入图片描述

  1. 二叉搜索
    首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除

在这里插入图片描述

3. 二叉搜索树的实现

3.1 准备工作

结点结构体BSTreeNode

我们实现二叉搜索树需要定义其结点，定义其左右节点以及value，方便后续操作进行

template<class K>
struct BSTreeNode      //二叉树结点
{
	typedef BSTreeNode<K> Node;     //简化名称

	Node* _left;        //左节点
	Node* _right;       //右节点
	K _key;             //结点value

	BSTreeNode(const K& key)    //构造函数
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}
};

二叉搜索树BinarySearchTree

template<class K>
class BinarySearchTree
{
	typedef BSTreeNode<K> Node;    //节点名称简化
public:
	.....         //二叉搜索树函数接口
private:
	Node* _root = nullptr;        //省略了初始化在定义的时候就进行初始化
};

3.2 函数体实现

📖bool Insert(const K& key)

实现思路：

二叉搜索树的定义是左边的子结点必定小于父节点，右边的子结点必定大于父节点，所以我们采取key值与节点value比较，如果key大于节点value，则继续与节点右子节点比较；如果key小于节点value，则继续与节点左子节点比较，最终如果走到空的位置，则进行插入。

这里我们需要定义一个parent节点帮助我们定位最终插入后其父节点的位置，然后将父节点与新插入的结点进行连接，将父节点的value与key值比较，若key大于value，那么肯定是被插入到父节点的右子树里了；若key小于value，则反之。

另：我们要独自判断空树的情况，不然会出现程序崩溃；搜索二叉树的每一个节点数值不能一样，那么我们如果插入的key与某个value相等，也会返回false

实现代码：

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;    //父节点
		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)

实现思路：

左边的子结点必定小于父节点，右边的子结点必定大于父节点，所以我们采取key值与节点value比较，如果key大于节点value，则继续与节点右子节点比较；如果key小于节点value，则继续与节点左子节点比较，最终如果走到空的位置，则返回false，如果找到与key相等的value，则返回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;
	}

📖打印二叉搜索树void InOrder()

实现思路：

使用递归实现中序遍历，二叉搜索树的中序遍历其实输出出来是一个递增排序的数组，从根节点开始，访问其左子树，并进行打印，然后访问右子树进行打印。
这里用了一个巧妙的方法： 我们对二叉搜索树打印需要传入根节点位置，才能进行递归，但是根节点为私有成员，我们要么写一个GetRoot()函数获取到根节点位置，才能传入，我们在这里可以对其进行封装，在上面重新定义一个打印函数，然后在这个函数里面调用刚刚的打印函数，并传入root，这样就不用在调用的时候传入root了。

实现代码：

	void InOrder()       //巧妙调用输出函数
	{
		_InOrder(_root);
		cout << endl;
	}

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

📖删除 Erase

实现思路：
二叉搜索树（Binary Search Tree，BST）的删除操作是指在BST中删除一个指定的节点。删除操作的模拟实现可以按照以下步骤进行：

首先，需要找到要删除的节点。从根节点开始，比较要删除的节点值与当前节点值的大小关系，如果相等则找到了要删除的节点，如果小于当前节点值，则继续在左子树中查找，如果大于当前节点值，则继续在右子树中查找。重复这个过程直到找到要删除的节点或者遍历到叶子节点为止。

如果找到了要删除的节点，需要考虑以下几种情况：

  1. 如果要删除的节点是叶子节点（没有子节点），直接删除即可。
  2. 如果要删除的节点只有一个子节点，将其子节点替代要删除的节点即可。
  3. 如果要删除的节点有两个子节点，需要找到其右子树中的最小节点（或者左子树中的最大节点），将其值替换到要删除的节点上，并将最小（或最大）节点删除。

实现删除操作时，需要注意维护BST的性质，即左子树中的所有节点值都小于当前节点值，右子树中的所有节点值都大于当前节点值。

实现代码：

	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 (cur == parent->_right)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}

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

					delete cur;
					return true;
				}
				else                          //左右子树都不为空
				{
					// 替换法
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					cur->_key = rightMin->_key;

					if (rightMin == rightMinParent->_left)     //根节点
						rightMinParent->_left = rightMin->_right;    
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
					return true;
				}
			}
		}

		return false;
	}

📖构造函数、析构函数、拷贝构造以及复制拷贝

这里直接实现，不再讲述原理，因为这一块比较基础了

	//强制生成默认构造
	BinarySearchTree() = default;

	BinarySearchTree(const BinarySearchTree<K>& t)   //拷贝构造函数
	{
		_root = Copy(t._root);
	}
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;

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

	BinarySearchTree<K>& operator=(const BinarySearchTree<K>& t)    //赋值拷贝
	{
		swap(_root, t._root);
		return *this;
	}

	~BinarySearchTree()   //析构函数
	{
		Destroy(_root);
	}

3.3 函数体实现(优化版)

我们的优化主要用了封装的艺术

📖优化版insert函数

我们在上面的函数实现时需要判断最终在左子树还是在右子树，并且还要定义一个parent来存储其父节点，而我们对其进行优化，可以看到我们在函数参数里加了一个Node*& root，正是这个参数，我们使用了引用，就不需要再判断其是左子树还是右子树，也不用记录其父节点，因为引用就是别名，我们对其进行修改就是对这个指针进行修改，这里还用了递归，让我们的代码量大大减小

public:
	bool InsertR(const K& key)      //函数放在public便于访问
	{
		return _InsertR(_root, key);
	}
private:                              //函数的具体实现放在private
	bool _InsertR(Node*& root,const K& key)   //这里使用别名，修改的就是其本身，就不用判断左右节点了
	{
		if (root == nullptr)
		{
			root=new Node(key);
			return true;
		}
		if (root->_key < key)                 //小于key就遍历右子树
		{
			return _InsertR(root->_right, key);
	}
		else if (root->_key > key)            //大于key就遍历左子树
		{
			return _InsertR(root->_left, key);  
		}
		else
		{
			return false;
		}
	}

📖优化版find函数

public:
	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	} 
private:
	bool _FindR(Node* root,const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return true;
		}
	}

📖优化版Erase函数

public:
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
private:
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;     //保存该节点便于删除
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* rightMin = root->_right;
				while (rightMin->_left)
				{
					rightMin = rightMin->_left;
				}

				swap(root->_key, rightMin->_key);

				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
	}

3.4 源代码BinarySearchTree.h

#pragma once

#include<iostream>
using namespace std;
template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;

	Node* _left;
	Node* _right;
	K _key;

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

template<class K>
class BinarySearchTree
{
	typedef BSTreeNode<K> Node;
public:
	//强制生成默认构造
	BinarySearchTree() = default;

	BinarySearchTree(const BinarySearchTree<K>& t)   //拷贝构造函数
	{
		_root = Copy(t._root);
	}
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;

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

	BinarySearchTree<K>& operator=(const BinarySearchTree<K>& t)    //赋值拷贝
	{
		swap(_root, t._root);
		return *this;
	}

	~BinarySearchTree()   //析构函数
	{
		Destroy(_root);
	}

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;    //父节点
		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 (cur == parent->_right)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}

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

					delete cur;
					return true;
				}
				else                          //左右子树都不为空
				{
					// 替换法
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					cur->_key = rightMin->_key;

					if (rightMin == rightMinParent->_left)     //根节点
						rightMinParent->_left = rightMin->_right;    
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
					return true;
				}
			}
		}

		return false;
	}


	void InOrder()       //巧妙调用输出函数
	{
		_InOrder(_root);
		cout << endl;
	}

///
	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	} 

	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
private:

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

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

	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;     //保存该节点便于删除
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* rightMin = root->_right;
				while (rightMin->_left)
				{
					rightMin = rightMin->_left;
				}

				swap(root->_key, rightMin->_key);

				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
	}

	bool _InsertR(Node*& root,const K& key)   //这里使用别名，修改的就是其本身，就不用判断左右节点了
	{
		if (root == nullptr)
		{
			root=new Node(key);
			return true;
		}
		if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else
		{
			return false;
		}
	}



	bool _FindR(Node* root,const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return true;
		}
	}

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

	Node* _root = nullptr;
};

4. 二叉搜索树的应用

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

比如:
给一个单词word，判断该单词是否拼写正确，具体方式如下：
以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

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

比如:
英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。

kv二叉树实现

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

		Node* _left;
		Node* _right;
		K _key;
		V _value;

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

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		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 (cur == parent->_right)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
						}

						delete cur;
						return true;
					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_left;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}

						delete cur;
						return true;
					}
					else
					{
						// 替换法
						Node* rightMinParent = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}

						cur->_key = rightMin->_key;

						if (rightMin == rightMinParent->_left)
							rightMinParent->_left = rightMin->_right;
						else
							rightMinParent->_right = rightMin->_right;

						delete rightMin;
						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;
	};
}

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

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
在这里插入图片描述

  1. 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为： l o g 2 N log_2 N log2​N
  2. 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为： N 2 \frac{N}{2} 2N​

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插
入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上
场了。

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

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

相关文章

IDEA 下载依赖包源码报错 Cannot download sources Sources not found for:XXX

IDEA 下载依赖包源码报错 Cannot download sources Sources not found for:XXX

最近在做一个功能的时候想看一个库的源码&#xff0c;结果源码下不下来&#xff0c;报Cannot download sources Sources not found for:XXX,网上搜了半天&#xff0c;也找不到靠谱的结论 后来想了下&#xff0c;应该是镜像那边出了问题&#xff0c;把镜像一删&#xff0c;源码…
阅读更多...
EPO企业生产运营数智化平台助力制造企业迈向智能制造

EPO企业生产运营数智化平台助力制造企业迈向智能制造

随着“中国制造2025”和工业4.0的不断推进&#xff0c;越来越多的制造企业准备迈入智能制造和智慧制造领域&#xff0c;实现数智化管理。企业通过搭建EPO企业生产运营平台&#xff0c;结合自身业务现状和数字化需求&#xff0c;从各个业务场景、部门人员、产品组成等方面进行分…
阅读更多...
(一)、Doris安装使用（基于Doris 2.0.6）

(一)、Doris安装使用（基于Doris 2.0.6）

第 1 章Doris简介 1.1、 Doris 概述 ​ Apache Doris由百度大数据部研发&#xff08;之前叫百度 Palo&#xff0c;2018年贡献到 Apache 社区后&#xff0c;更名为 Doris&#xff09;&#xff0c;在百度内部&#xff0c;有超过200个产品线在使用&#xff0c;部署机器超过1000台…
阅读更多...
国际品牌交期长 雷卯来帮忙

国际品牌交期长 雷卯来帮忙

在当今的电子元器件市场中&#xff0c;防静电电子元器件的需求日益增长。无论是通信安防、医疗、消费类电子、照明行业、航空航天还是汽车电子等领域都会使用到防静电产品&#xff0c;使得防静电电子元器件的需求也呈现出爆发式的增长。在这一市场中&#xff0c;雷卯品牌凭借其…
阅读更多...
Chain of Note-CoN增强检索增强型语言模型的鲁棒性

Chain of Note-CoN增强检索增强型语言模型的鲁棒性

Enhancing Robustness in Retrieval-Augmented Language Models 检索增强型语言模型&#xff08;RALMs&#xff09;在大型语言模型的能力上取得了重大进步&#xff0c;特别是在利用外部知识源减少事实性幻觉方面。然而&#xff0c;检索到的信息的可靠性并不总是有保证的。检索…
阅读更多...
六.排序nb三人组(快速排序)

六.排序nb三人组(快速排序)

目录 17-快速排序原理介绍 思路: 18-快速排序代码实现 19-快速排序代码实现2 缺点: 递归的限度: 17-快速排序原理介绍 思路: --先找一个变量把 5(第一个数) 存起来, (两个箭头分别是left , right) --左边有一个空位, 发现左边的位置是给比5小的值准备的. --找比5小的值…
阅读更多...
算法体系-12 第 十二 二叉树的基本算法 下

算法体系-12 第 十二 二叉树的基本算法 下

一 实现二叉树的按层遍历 1.1 描述 1&#xff09;其实就是宽度优先遍历&#xff0c;用队列 2&#xff09;可以通过设置flag变量的方式&#xff0c;来发现某一层的结束&#xff08;看题目&#xff09;看下边的第四题解答 1.2 代码 public class Code01_LevelTraversalBT {publ…
阅读更多...
【LabVIEW FPGA入门】FPGA不同传递数据方法比较

【LabVIEW FPGA入门】FPGA不同传递数据方法比较

数据共享方法的选择应基于应用的需要。根据应用程序的重要特性&#xff0c;所讨论的任何一种方法都可能是合适的。 传输方法FPGA资源损耗&#xff1f;不同时钟源之间传递数据&#xff1f;新数据通知&#xff1f;常见用途变量逻辑片是是否提取最新数据存储器存储器是否否提取最新…
阅读更多...
ubuntu20.04_PX4_1.13

ubuntu20.04_PX4_1.13

说在前面&#xff1a;&#xff08;最好找一个干净的Ubuntu系统&#xff09;如果配置环境的过程中出现很多编译的错误或者依赖冲突&#xff0c;还是建议新建一个虚拟机&#xff0c;或者重装Ubuntu系统&#xff0c;这样会避免很多麻烦&#x1f490; &#xff0c; 安装PX4 1.13.2 …
阅读更多...
学习刷题-12

学习刷题-12

3.22 hw机试【双指针】 Leetcode674 最长连续递增序列 给定一个未经排序的整数数组&#xff0c;找到最长且 连续递增的子序列&#xff0c;并返回该序列的长度。 双指针 一个慢指针一个快指针 慢指针记录递增子序列起点&#xff0c;快指针去寻找还在当前递增子序列的最后一…
阅读更多...
Nutanix 国产化替代｜一文了解 SmartX 超融合替代可行性与迁移方案

Nutanix 国产化替代｜一文了解 SmartX 超融合替代可行性与迁移方案

2022 年 8 月 19 日&#xff0c;Nutanix&#xff08;路坦力&#xff09;宣布中国市场自 2023 财年起将转型为合作伙伴销售主导模式&#xff0c;引起了广泛关注&#xff1b;同时结合当前 IT 基础架构的国产化趋势背景&#xff0c;不少正在使用和考虑使用 Nutanix 产品的企业开始…
阅读更多...
基于Nvidia的ChatGPT实现智能回答(附完整代码)

基于Nvidia的ChatGPT实现智能回答(附完整代码)

目录 首先&#xff0c;我们需要在英伟达官网上找到相关的API-key 第二步&#xff0c;编写代码&#xff0c;调用API即可实现代码复用。 Python完整代码&#xff1a; Node版代码&#xff1a; Shell脚本代码&#xff1a; 最后我们在相应的编译器执行代码即可&#xff0c;在这里我们…
阅读更多...
重学SpringBoot3-MyBatis的三种分页方式

重学SpringBoot3-MyBatis的三种分页方式

更多SpringBoot3内容请关注我的专栏&#xff1a;《SpringBoot3》 期待您的点赞&#x1f44d;收藏⭐评论✍ 重学SpringBoot3-MyBatis的三种分页方式 准备工作环境搭建数据准备未分页效果 1. 使用MyBatis自带的RowBounds进行分页演示 2. 使用物理分页插件演示 3. 手动编写分页SQL…
阅读更多...
软件测试-概念

软件测试-概念

衡量软件测试结果的依据--需求 需求的概念 满足用户期望或正式规定文档(合同, 规范, 标准)所具备的条件或权能, 包含用户需求和软件需求. IEEE:定义: 软件需求是(1)用户解决问题或达到目标所需的条件或权能. (2)系统或系统部件要满足合同, 标准, 规范或其它正式规定文档所具备…
阅读更多...
MySQL、Oracle的时间类型字段自动更新：insert插入、update更新时，自动更新时间戳。设置自增主键id，oracle创建自增id序列和触发器

MySQL、Oracle的时间类型字段自动更新：insert插入、update更新时，自动更新时间戳。设置自增主键id，oracle创建自增id序列和触发器

1. MySQL 支持设置自增id的字段类型&#xff1a;int、bigint、double等数值类型&#xff0c;一般用int、bigint支持设置自动更新时间的字段类型&#xff1a;datetime、timestamp下面sql中的now()函数可以用current_timestamp()替代 1.1. 不指定秒精度 drop table if exists …
阅读更多...
一文读懂IP地址

一文读懂IP地址

IP地址&#xff08;Internet Protocol Address&#xff09;是指互联网协议地址&#xff0c;是IP协议提供的一种统一的地址格式&#xff0c;它为互联网上的每一个网络和每一台主机分配一个逻辑地址&#xff0c;以此来屏蔽物理地址的差异。IP地址的主要特点是具有唯一性&#xff…
阅读更多...
【神经网络】得分函数，损失函数～

【神经网络】得分函数，损失函数～

目录 引言 一、神经网络概述 1 定义 2 基本原理 二、得分函数 1 定义 2 应用方法 3 与神经网络 三、损失函数 1 定义 2实现方法 3 与神经网络 四、得分函数与损失函数的协同作用 1 关系 2 实际应用 六、代码事例 &#xfffc;、总结与展望 引言 在人工智能与机…
阅读更多...
【GO全栈掌握入门】

【GO全栈掌握入门】

GO语言全栈学习咯 ~ 1. GO 语言简介2.语言特性3.哪些公司使用GO语言&#xff1f;3. 安装GO开发环境4. 学习说明&#xff1a;5. GO结构篇5.1 工作空间5.2 导入包5.3 组织结构5.4 依赖管理 6. GO骨肉篇7.GO工具篇 1. GO 语言简介 起源于2007年&#xff0c;GO语言之年轻如你所见&…
阅读更多...
CodeSys创建自定义的html5控件

CodeSys创建自定义的html5控件

文章目录 背景创建html5control.xml文件控件界面以及逻辑的实现使用的资源安装自定义的html5控件库 背景 查看官方的资料&#xff1a;https://content.helpme-codesys.com/en/CODESYS%20Visualization/_visu_html5_dev.html 官方的例子&#xff1a;https://forge.codesys.com/…
阅读更多...
AI火灾监测报警摄像机

AI火灾监测报警摄像机

AI火灾监测报警摄像机&#xff0c;作为一种结合人工智能技术和摄像监控技术的创新产品&#xff0c;在火灾防控领域发挥着越来越重要的作用。这种摄像机通过先进的AI算法&#xff0c;能够实时监测摄像头画面&#xff0c;识别出火灾的特征&#xff0c;如火光、浓烟等。一旦检测到…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023