[数据结构进阶 C++] 二叉搜索树(BinarySearchTree)的模拟实现

news2025/2/4 10:58:36

在这里插入图片描述

文章目录

  • 1、二叉搜索树
    • 1.1 二叉搜索数的概念
    • 1.2 二叉搜索树的操作
      • 1.2.1 二叉搜索树的查找
      • 1.2.2 二叉搜索树的插入
      • 1.2.3 二叉搜索树的删除
  • 2、二叉搜索树的应用
    • 2.1 K模型
    • 2.2 KV模型
  • 3、二叉搜索树的性能分析
  • 4、K模型与KV模型完整代码
    • 4.1 二叉搜索树的模拟实现（K模型）
    • 4.2 KV模型的模拟实现

1、二叉搜索树

1.1 二叉搜索数的概念

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

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树
    我们先给出两个示例：
    在这里插入图片描述
    此二叉树就不是搜索二叉树，根据性质来看，每颗子树也是二叉搜索树，红圈圈起来的地方显然是违背了这个性质。
    在这里插入图片描述
    此搜索二叉树按性质来看是完全满足的，因此此二叉树就是二叉搜索树。

1.2 二叉搜索树的操作

二叉搜索树的操作包含，增删查，下面我们就来分别模拟实现这些接口。

1.2.1 二叉搜索树的查找

思路：
a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。
查找比较好理解，这里就不画图了，直接开始写代码。
1.查找的非递归方法：

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

2.查找的递归方法：

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

bool _FindR(Node* root, const K& key)
{
    if (nullptr == root)
        return false;

    if (key > root->_key)
        return _FindR(root->_right, key);
    else if (key < root->_key)
        return _FindR(root->_left, key);
    else
        return true;
}

在递归查找中，我们用户在使用的时候只需要填入要查找的数字，但是我们的查找接口需要两个参数，开始节点与查找数值，因此我们在 FindR 下再封装一层 _FindR 就可以实现了。

1.2.2 二叉搜索树的插入

二叉搜索树的插入思路：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
我们先来以图例演示一遍过程：
对下面这棵树插入一个值为11的节点
在这里插入图片描述

这里是成功插入的情况，具体过程是上面的图例，我们在梳理一遍：
1、首先，我们用两个结点指针 parent和cur ，cur不断寻找正确插入位置，parent不断记下来cur的父节点指针；
2、当 cur 找到正确位置之后，先 new 一个节点对象给 cur，此时 new 出来的对象只是给了 cur 这个指针变量，并没有链接起来；
3、判断要插入的位置是 parent 的左孩子还是右孩子，再将其链接到正确位置插入就算完成了。
失败情况：
因为是二叉搜索树，节点左子树的值全小于节点的值，右子树的值全大于节点的值，不存在相等的情况，因此当找到一个节点的值与要插入的值相等时，就是插入失败，此时返回false。
根据上面的图示以及过程的梳理我们来写非递归版本的代码：

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

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

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

insert接口我们只提供非递归版本的。

1.2.3 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下：
情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点
中，再来处理该结点的删除问题–替换法删除
1、删除节点没有左孩子
在这里插入图片描述

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

2、删除节点没有右孩子
在这里插入图片描述

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

    if (parent->_left == cur)
    {
        parent->_left = cur->_left
    }
    else
    {
        parent->_right = cur->_left;
    }
}

3、删除节点左右孩子都存在
在这里插入图片描述

// 3、左右都不为空
else
{
    Node* parent = cur;
    Node* subLeft = cur->_right;
    while (subLeft->_left)
    {
        parent = subLeft;
        subLeft = subLeft->_left;
    }

    swap(cur->_key, subLeft->_key);
    
    if (subLeft == parent->_left)
        parent->_left = subLeft->_right;
    else
        parent->_right = subLeft->_right;

    delete(subLeft);
}

整个删除接口合在一起的代码：

bool Erase(const K& key)
{
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (key > cur->_key)
        {
            parnet = cur;
            cur = cur->_right
        }
        else if (key < cur->_key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            // 1、左为空
            if (cur->_left == nullptr)
            {
                if (cur == _root)
                {
                    _root = cur->_right;
                }

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

                if (parent->_left == cur)
                {
                    parent->_left = cur->_left
                }
                else
                {
                    parent->_right = cur->_left;
                }
                delete(cur);
            }
            // 3、左右都不为空
            else
            {
                Node* parent = cur;
                Node* subLeft = cur->_right;
                while (subLeft->_left)
                {
                    parent = subLeft;
                    subLeft = subLeft->_left;
                }

                swap(cur->_key, subLeft->_key);
                
                if (subLeft == parent->_left)
                    parent->_left = subLeft->_right;
                else
                    parent->_right = subLeft->_right;

                delete(subLeft);
            }
        }
    }	
}

递归版本：
递归版本与非递归版本类似， 非递归版本中使用while循环来找key位置，递归就是不断调用自身来找key位置，当找到后，依然分三种情况来分析：左为空、右为空、左右都不为空。
递归版本中用引用来接受传来的root，因此不用考虑链接问题，也就不存在判断删除位置是父节点的左还是右，直接修改root即可。
1、左为空/左右都为空：先记下要删除的节点，再修改root，最后释放删除的节点。 Node* del = root; root = root->_right; delete(del);
2、右为空：先记下要删除的节点，再修改root，最后释放删除的节点。Node* del = root; root = root->_left; delete(del);
3、左右都不为空：先找到右子树的最左节点（最小值），交换 root->_key与subLeft->_key， 右子树的最左节点一定是叶子节点，因此删除subLeft直接再去调用函数自身即可，即再来一次左右都为空（左为空）的删除。

bool EraseR(const K& key)
{
    return _EraseR(_root, key);
}
bool _EraseR(Node*& root, const K& key)
{
    if (root == nullptr)
        return false;

    if (root->_key < key)
    {
        _EraseR(root->_right, key);
    }
    else if (root->_key > key)
    {
        _EraseR(root->_left, key);
    }
    else
    {
        if (root->_left == nullptr)
        {
            Node* del = root;
            root = root->_right;
            delete(del);// 必须释放，不释放会导致内存泄漏
            return true;
        }
        else if (root->_right == nullptr)
        {
            Node* del = root;
            root = root->_left;
            delete(del);
            return true;
        }
        else
        {
            Node* subLeft = root->_right;
            while (subLeft->_left)
            {
                subLeft = subLeft->_left;
            }

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

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

2、二叉搜索树的应用

2.1 K模型

K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

  • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
  • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2.2 KV模型

KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。 该种方式在现实生活中非常常见：
● 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
● 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。

3、二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
在这里插入图片描述
最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log_2 N
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N
最差情况是退化为单支树，性能就变得很差了，因为后续我们将改进搜索二叉树的插入与删除，来实现平衡二叉搜索树，即AVL树与红黑树（RB树）。

4、K模型与KV模型完整代码

4.1 二叉搜索树的模拟实现（K模型）

namespace key
{
	template <class K>
	struct BSTreeNode
	{
		BSTreeNode* _left;
		BSTreeNode* _right;
		K _key;
		BSTreeNode(const K& key)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};

	template <class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	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 true;
		}

		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
				{
					// 删除分情况讨论：
					// 1. 左为空（左右都为空）；2. 右为空；3.左右都不为空
					if (cur->_left == nullptr)// 左为空
					{
						if (cur == _root)// 根节点是删除的节点情况
							_root = cur->_right;
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete(cur);
					}
					else if (cur->_right == nullptr)// 右为空
					{
						if (cur == _root)// 根节点是删除的节点情况
							_root = cur->_left;
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete(cur);
					}
					else// 左右都不为空
					{
						// 替换法，找左子树最大 / 右子树最小来替换cur
						Node* parent = cur;
						Node* subLeft = cur->_right;
						while (subLeft->_left)
						{
							parent = subLeft;
							subLeft = subLeft->_left;
						}

						swap(cur->_key, subLeft->_key);

						if (subLeft == parent->_left)
							parent->_left = subLeft->_right;
						else// 处理删除根节点的情况
							parent->_right = subLeft->_right;

						delete(subLeft);
					}
					return true;
				}
			}
			return false;
		}

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

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

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

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

		// C++11
		BSTree() = default; // 强制编译器生成默认构造

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

		// 赋值重载，现代写法
		BSTree<K>& operator=(BSTree<K> t)
		{
			swap(_root, t._root);
			return *this;
		}

		~BSTree()
		{
			Destroy(_root);
		}

	private:
		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 newRoot;
		}

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

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

		bool _InsertR(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);
				return true;
			}

			if (root->_key < key)
			{
				_InsertR(root->_right, key);
			}
			else if (root->_key > key)
			{
				_InsertR(root->_left, key);
			}
			else
			{
				return false;
			}
		}

		bool _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}

			if (root->_key < key)
			{
				_FindR(root->_right, key);
			}
			else if (root->_key > key)
			{
				_FindR(root->_left, key);
			}
			else
			{
				return true;
			}
		}

		bool _EraseR(Node*& root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key < key)
			{
				_EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				_EraseR(root->_left, key);
			}
			else
			{
				if (root->_left == nullptr)
				{
					Node* del = root;
					root = root->_right;
					delete(del);// 必须释放，不释放会导致内存泄漏
					return true;
				}
				else if (root->_right == nullptr)
				{
					Node* del = root;
					root = root->_left;
					delete(del);
					return true;
				}
				else
				{
					Node* subLeft = root->_right;
					while (subLeft->_left)
					{
						subLeft = subLeft->_left;
					}

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

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

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

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

	private:
		Node* _root = nullptr;
	};
};

4.2 KV模型的模拟实现

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

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

	template <class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		bool Insert(const K& key, const V& val)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, val);
				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, val);
			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
				{
					// 删除分情况讨论：
					// 1. 左为空（左右都为空）；2. 右为空；3.左右都不为空
					if (cur->_left == nullptr)// 左为空
					{
						if (cur == _root)// 根节点是删除的节点情况
							_root = cur->_right;
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete(cur);
					}
					else if (cur->_right == nullptr)// 右为空
					{
						if (cur == _root)// 根节点是删除的节点情况
							_root = cur->_left;
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete(cur);
					}
					else// 左右都不为空
					{
						// 替换法，找左子树最大 / 右子树最小来替换cur
						Node* parent = cur;
						Node* subLeft = cur->_right;
						while (subLeft->_left)
						{
							parent = subLeft;
							subLeft = subLeft->_left;
						}

						swap(cur->_key, subLeft->_key);

						if (subLeft == parent->_left)
							parent->_left = subLeft->_right;
						else// 处理删除根节点的情况
							parent->_right = subLeft->_right;

						delete(subLeft);
					}
					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->_val << endl;
			_InOrder(root->_right);
		}

	private:
		Node* _root = nullptr;
	};
};

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

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

相关文章

养老院自助饮水机（字符设备驱动）

养老院自助饮水机（字符设备驱动）

目录 1、项目背景 2、驱动程序 2.1 三层架构 2.2 驱动三要素 2.3 字符设备驱动 2.3.1 驱动模块 2.3.2 应用层 3、设计实现 3.1 项目设计 3.2 项目实现 3.2.1 驱动模块代码 3.2.2 用户层代码 4、功能特性 5、技术分析 6. 总结与未来展望 1、项目背景 养老院的老人…
阅读更多...
CSC访问学者/博士后/联培博士如何规划申请时间

CSC访问学者/博士后/联培博士如何规划申请时间

申请国家留学基金委&#xff08;CSC&#xff09;公派访问学者/博士后/联合培养博士等出国项目&#xff0c;邀请函是必要条件&#xff0c;需提前准备。那么&#xff0c;何时提出申请比较合适&#xff1f;获得邀请函需要多长时间&#xff1f;根据知识人网多年的申请经验&#xff…
阅读更多...
电影《名侦探柯南：黑铁的鱼影》观后感

电影《名侦探柯南：黑铁的鱼影》观后感

上周看了电影《名侦探柯南&#xff1a;黑铁的鱼影》,整体故事的话,就是柯南他们团队一起去岛屿去上参观&#xff0c;“正好”碰上了“海上信标案件”&#xff0c;在柯南的电影里&#xff0c;用“正好”多少有些反讽的意味&#xff0c;因为柯南好像走到哪&#xff0c;都正好碰到…
阅读更多...
Python实验报告十一、自定义类模拟三维向量及其运算

Python实验报告十一、自定义类模拟三维向量及其运算

一、实验目的&#xff1a; 1、了解如何定义一个类。 2、了解如何定义类的私有数据成员和成员方法。 3、了解如何使用自定义类实例化对象。 二、实验内容&#xff1a; 定义一个三维向量类&#xff0c;并定义相应的特殊方法实现两个该类对象之间的加、减运算&#xff08;要…
阅读更多...
Vue中为什么data属性是一个函数而不是一个对象？（看完就会了）

Vue中为什么data属性是一个函数而不是一个对象？（看完就会了）

文章目录 一、实例和组件定义data的区别二、组件data定义函数与对象的区别三、原理分析四、结论 一、实例和组件定义data的区别 vue实例的时候定义data属性既可以是一个对象&#xff0c;也可以是一个函数 const app new Vue({el:"#app",// 对象格式data:{foo:&quo…
阅读更多...
优化企业员工管理的利器——ADManager Plus

优化企业员工管理的利器——ADManager Plus

在当今数字化的商业环境中&#xff0c;企业员工管理是组织成功运营的关键组成部分。为了提高效率、确保安全性和满足法规合规性要求&#xff0c;企业需要一种强大的工具来简化和集中管理其活跃目录&#xff08;Active Directory&#xff09;环境。ADManager Plus作为一款功能丰…
阅读更多...
利用ffmpeg cv2取h265码流视频（转换图片灰屏问题解决)

利用ffmpeg cv2取h265码流视频（转换图片灰屏问题解决)

利用海康威视相机拍出来的视频是H265格式的&#xff0c;相比于常规的H264编码&#xff0c;压缩率更高&#xff0c;但因此如果直接用正常取流方法读取&#xff0c;会出现无法读取的情况 1. 如图h265码流取出图片为灰屏 2 、解决灰屏问题 import subprocess import cv2# 将h265流…
阅读更多...
天津web前端就业培训班，Web机构选择重点

天津web前端就业培训班，Web机构选择重点

Web前端培训是目前非常热门的培训领域之一。很多领域都会涉及到web前端开发&#xff0c;比如传统互联网、房地产、金融、游戏、影视传媒等行业都需要web前端技术的支持。越来越多的企业和个人也需要建立自己的网站和移动应用程序&#xff0c;因此市场对web前端工程师的需求是非…
阅读更多...
RabbitMQ笔记(基础篇)

RabbitMQ笔记(基础篇)

RabbitMQ笔记_基础篇 MQ基本概念1. MQ概述2. MQ的优势和劣势2.1 优势☆2.2 劣势2.3 使用 MQ 需要满足什么条件呢&#xff1f; 3. 常见的MQ产品 RabbitMQ基本介绍1. RabbitMQ 基础架构2. RabbitMQ 中的相关概念3. RabbitMQ的6 种工作模式☆4. AMQP 和 JMS4.1 AMQP4.2 JMS4.3 AMQ…
阅读更多...
文件夹数据同步工具 Sync Folders Pro mac支持选项

文件夹数据同步工具 Sync Folders Pro mac支持选项

Sync Folders Pro for Mac 是一款功能强大的文件夹同步工具&#xff0c;旨在帮助用户在 Mac 计算机和移动设备之间创建双向同步。这款软件支持各种文件系统和设备&#xff0c;如 iPhone&#xff0c;iPad&#xff0c;iPod&#xff0c;Android 等。通过这款软件&#xff0c;用户可…
阅读更多...
[c]超半的数

[c]超半的数

题目意思很简单&#xff0c;就是输入一组数据&#xff0c;输出出现次数过半的数 根据这个题我们也可以写出另一个题&#xff0c;&#xff08;题2&#xff09;&#xff08;统计一组数据中各个数出现的次数&#xff09; 下面附上两个题代码 题1&#xff1a; #include<stdio.…
阅读更多...
【C语言】自定义类型：结构体深入解析（二）结构体内存对齐宏offsetof计算偏移量结构体传参

【C语言】自定义类型：结构体深入解析（二）结构体内存对齐宏offsetof计算偏移量结构体传参

文章目录 &#x1f4dd;前言&#x1f320; 结构体内存对齐&#x1f309;内存对齐包含结构体的计算&#x1f320;宏offsetof计算偏移量&#x1f309;为什么存在内存对⻬?&#x1f320; 结构体传参&#x1f6a9;总结 &#x1f4dd;前言 本小节&#xff0c;我们学习结构的内存对…
阅读更多...
什么是网络工程师? 就业前景好吗？

什么是网络工程师? 就业前景好吗？

互联网发展日渐成熟&#xff0c;所有企业都依赖于网络管理&#xff0c;有企业的地方就需要网络工程师。 在一般人的概念里&#xff0c;网络工程师不过就是通过拨号上网&#xff0c;发个Email&#xff0c;聊聊天&#xff0c;计算机组装与维护&#xff0c;组建局域网就以为是网络…
阅读更多...
项目进度管理：常用项目管理工具推荐

项目进度管理：常用项目管理工具推荐

工欲善其事必先利其器&#xff0c;借助项目管理工具可以帮助项目经理更好的管理项目&#xff0c;起到事半功倍的效果。 使用项目管理工具来管理项目&#xff0c;有助于事情的快速落地&#xff0c;提升做事效率&#xff0c;也能让事情做的更周到全面 选择项目管理工具时可以参…
阅读更多...
uniapp、微信小程序类似mui中的chat（聊天窗口）

uniapp、微信小程序类似mui中的chat（聊天窗口）

在mui中有chat界面的例子&#xff0c;升级到uni-app后&#xff0c;没有类似的模板&#xff0c;因此模仿写了一个。遇到了一些坑&#xff0c;在此一一记录下来。当然&#xff0c;由于是新手&#xff0c;可能有些坑可以避开。 预览效果 scroll-view高度的设置 输入内容后&#…
阅读更多...
室内导航技术在智慧医疗的革新应用

室内导航技术在智慧医疗的革新应用

随着科技的飞速发展&#xff0c;智慧医疗已经成为现代医疗服务的重要组成部分。在这个背景下&#xff0c;室内导航技术逐渐崭露头角&#xff0c;为智慧医疗建设带来了革命性的改变。本文将深入探讨室内导航技术在智慧医疗中的应用&#xff0c;并分析其为医疗服务带来的诸多便利…
阅读更多...
3分钟部署自己独享的Gemini

3分钟部署自己独享的Gemini

3分钟部署自己独享的Gemini 在前面的几篇文章中&#xff0c;分别介绍了Gemini Pro的发布和Gemini Pro API的详细申请步骤&#xff0c;那么今天给大家分享的是如何快速搭建一个属于自己的Gemini 。 1️⃣ 准备工作 科学网络环境Github账号和Vercel账号Gemini Pro API Key&…
阅读更多...
一个抖店内做几个商品链接比较合适？解答下新手问题，建议收藏

一个抖店内做几个商品链接比较合适？解答下新手问题，建议收藏

我是王路飞。 一个抖店内的商品链接数量&#xff0c;是多一些比较好还是少一些比较好呢&#xff1f; 可能在大多数人看来&#xff0c;当然是多一些比较好了&#xff0c;商品数量更多&#xff0c;基数增加&#xff0c;也能承载更多的进店流量&#xff0c;增加下单几率。 但真…
阅读更多...
数智金融技术峰会|数新网络受邀分享《金融信创湖仓一体数据平台架构实践》，敬请期待

数智金融技术峰会|数新网络受邀分享《金融信创湖仓一体数据平台架构实践》，敬请期待

12月23日&#xff0c;数新网络参加DataFunSummit 2023&#xff1a;数智金融技术峰会。会上&#xff0c;数新CTO原攀峰将为大家带来《金融信创湖仓一体数据平台架构实践》 主题分享。 本次峰会由DataFun联合火山引擎、蓝驰等知名企业举办&#xff0c;将共同为大家带来一场数智金…
阅读更多...
Docker 编译OpenHarmony 4.0 release

Docker 编译OpenHarmony 4.0 release

一、背景介绍 1.1、环境配置 编译环境&#xff1a;Ubuntu 20.04OpenHarmony版本&#xff1a;4.0 release平台设备&#xff1a;RK3568 OpenHarmony 3.2更新至OpenHarmony 4.0后&#xff0c;公司服务器无法编译通过&#xff0c;总是在最后几十个文件时报错,错误码4000&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023