[数据结构]-二叉搜索树

news2024/9/27 21:22:50

前言

作者：小蜗牛向前冲

名言：我可以接受失败，但我不能接受放弃

 如果觉的博主的文章还不错的话，还请点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正。

目录

一、二叉搜索树的基本知识

1、什么是二叉搜索树

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

二、底层模拟实现

1、构建二叉搜索树

2、二叉搜索树的查找

3、二叉搜索树的插入

4、二叉搜索树的删除节点

 5、完整代码实现

三、二叉搜索树的应用

1、K模型

2、KV模型

 本期学习目标：清楚什么是二叉搜索树，模拟实现二叉搜索树，理解二叉搜索树的K模型和KV模型。

一、二叉搜索树的基本知识

1、什么是二叉搜索树

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

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

二叉搜索树的这种特性使得在其中进行搜索、插入和删除操作具有高效性能。通过对节点值的比较，我们可以迅速定位目标节点或确定应插入的位置。

上图中就是二叉搜索树的构成，他满足所有左叶子节点比跟小，所以的右叶子节点比根要大。

为了更好的理解二叉搜索树，下面将带来大家底层实现二叉搜索树的查找，插入，删除。

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

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

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

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

二、底层模拟实现

1、构建二叉搜索树


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

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

	template<class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	public://函数
	private:
         Node* _root = nullptr;
    }

这里我们定义好节点，和树的主体就好了，下面我的二叉搜索树的功能函数多在类中实现。

2、二叉搜索树的查找

现在给我们一颗搜索二叉树，那我们是如何让他查找到我们想要的元素

查找原则：

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

顺着这个思路我们很容易思路就可以写出查找： 

普通写法：

//查找
bool Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key > key)
		{
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			cur = cur->_right;
		}
		else
		{
			return true;
		}
	}
	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;
	}
}

这二种写法，在这里好像看不出来特别大的差别。

3、二叉搜索树的插入

这里我们思考一下，如果我们要在1处插入 0

我们要找到插入的位置。然后在new一个节点进连接就可以

插入的具体过程如下：

a. 树为空，则直接新增节点，赋值给root指针

b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

普通写法： 

	bool Inert(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->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		//创建节点
		cur = new Node(key);

		//连接树
		if (parent->_key > key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		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;
			}
		}

递归写法最让我们感到绝妙的是我们在这里传root用的是引用，因为用递归时(如果没有用root的引用)并没有传父亲节点，这也就在连接的时候会遇到到问题，但是我们这里传了root的引用就可以解决这个问题

这里当我们要插入9，到我们递归到root == 10时候,在进行递归时，会往root->left递归，指向空,就可以插入，而&root是root->left指针的别名，就可以完美的连接起来。

4、二叉搜索树的删除节点

这里是本次模拟的难点所在，大家可以细细品味：

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

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

其实我们可以总结为3种删除情况：

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

普通写法：

这里我们重点注意第三种情况，这里我们是找左树的最大或者说是右树的最小和我们要删除的数，进行替换在删除就可以了。

//删除
bool Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		//先找到要删除的数
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			//1、左为空
			//2、右为空
			// 1.2都可以直接删除
			//在直接删除前，我们还要做好cur的左右节点的链接工作，并处理特殊情况(cur==_root)
			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;
			}

递归写法：

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* minRight = root->_right;
			while (minRight->_left)
			{
				minRight = minRight->_left;
			}

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

			//转换为在子树中删除节点

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

 5、完整代码实现

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

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

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

		//默认构造
		BSTree()
			:_root(nullptr)
		{}

		//构造函数
		BSTree(const BSTree<K>& t)
		{
			_root = Copy(t._root);
		}

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

		//析构函数
		~BSTree()
		{
			Destroy(_root);
			_root = nullptr;
		}
		//搜索二插树插入
		bool Inert(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->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					return false;
				}
			}
			//创建节点
			cur = new Node(key);

			//连接树
			if (parent->_key > key)
			{
				parent->_left = cur;
			}
			else
			{
				parent->_right = cur;
			}
			return true;
		}



		//查找
		bool Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					cur = cur->_right;
				}
				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->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					//1、左为空
					//2、右为空
					// 1.2都可以直接删除
					//在直接删除前，我们还要做好cur的左右节点的链接工作，并处理特殊情况(cur==_root)
					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;
					}
					//3、左右都不为空
					//找cur右子数的最小节点
					else
					{
						Node* parent = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							parent = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						//连接
						if (parent->_left == minRight)
						{
							parent->_left = minRight->_right;
						}
						else
						{
							parent->_right = minRight->_right;
						}

						//删除节点
						delete minRight;
					}

					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);
		}
		//递归写法完成增删查改
	private:

		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);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);

			return newRoot;
		}

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

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

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

		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* minRight = root->_right;
					while (minRight->_left)
					{
						minRight = minRight->_left;
					}

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

					//转换为在子树中删除节点

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

	private:
		Node* _root = nullptr;
	};
}

三、二叉搜索树的应用

1、K模型

K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到 的值。 比如：给一个单词word，判断该单词是否拼写正确，具体方式如下： 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

这里就是我们完整实现的二叉树，这里我们用二叉搜索树的查找功能，如果该单词存在树中就会返回true，否则返回false。

2、KV模型

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

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

这里我们上面代码进行简单改造就可以得到我们的KV模型：

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

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

	//BSTree<string, vector<string>> bookInfo;

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

		void Inorder()
		{
			_Inorder(_root);
		}

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

			_Inorder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_Inorder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
}

void TestBSTree2()
{
// Key/Value的搜索模型,通过Key查找或修改Valu
	KV::BSTree<string, string> dict;
	dict.Insert("sort", "排序");
	dict.Insert("string", "字符串");
	dict.Insert("left", "左边");
	dict.Insert("right", "右边");

	string str;
	while (cin >> str)
	{
		KV::BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret)
		{
			cout << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}

这里我们对改造的二叉搜索树，就可以进行通过英文快速找到英文。

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

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

相关文章

利用Linux socat快速搭建TCP服务器

利用Linux socat快速搭建TCP服务器

某些场合&#xff0c;需要在Linux上快速搭建一个TCP的服务器&#xff0c;接收客户端的连接&#xff0c;返回一些数据。 一般用于测试或者负载不大&#xff0c;安全性要求不高的场合&#xff0c;达到快速搭建的目的。 本文以客户端通过服务器的3334端口&#xff0c;获取服务器…
阅读更多...
什么是残差网络结构

什么是残差网络结构

大家好啊&#xff0c;我是董董灿。 在我刚开始学习AI算法时&#xff0c;有一次参加一个线下的讨论&#xff0c;有个西南大学的本科生&#xff0c;在做汇报时说到了残差网络具有很好的推理效果。 那时的我还未入门&#xff0c;像是听天书&#xff0c;听了半天没搞懂说的啥意思…
阅读更多...
【c++】模拟实现优先级队列（priority_queue）

【c++】模拟实现优先级队列（priority_queue）

全部代码 以容器适配器的玩法来实现&#xff0c;底层容器默认为vector 使用了模板参数T表示存储在队列中的元素类型&#xff0c;Container表示底层容器类型&#xff0c;默认为vector&#xff0c;Compare表示比较器类型&#xff0c;默认为less。 adjustDown函数用于向下调整堆…
阅读更多...
高速下载b站视频的解决方案

高速下载b站视频的解决方案

大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的…
阅读更多...
【C语言】关于char的取值范围的讨论

【C语言】关于char的取值范围的讨论

前提知识&#xff1a; 计算机内存中存的是整数的补码。 正数的原反补相同&#xff01; 负数的补码 &#xff08;除符号位以外&#xff09;原码取反 1 负数的源码 &#xff08;除符号位以外&#xff09;补码取反 1 有符号的char&#xff0c;最高位二进制位表示符号位 …
阅读更多...
基于 MTAOO 方法论，看连锁餐饮品牌如何落地 CJO 理念、实现精细化用户运营

基于 MTAOO 方法论，看连锁餐饮品牌如何落地 CJO 理念、实现精细化用户运营

移动互联网时代的流量红利已经消失&#xff0c;企业亟需在数字化转型时代抓住触点红利&#xff0c;基于客户旅程编排&#xff08;Customer Journey Orchestration&#xff0c;简称 CJO&#xff09;为用户提供个性化、全渠道一致的体验。 在此背景下&#xff0c;连锁餐饮品牌已经…
阅读更多...
《C和指针》笔记34：字符串函数

《C和指针》笔记34：字符串函数

文章目录 1. 获取字符串长度strlen 2. 复制字符串strcpystrncpy 3. 拼接字符串strcatstrncat 4. 字符串比较strcmpstrncmp 1. 获取字符串长度 strlen 库函数strlen的原型如下&#xff1a; size_t strlen( char const *string );注意strlen返回一个类型为size_t的值。这个类型…
阅读更多...
【GIT】：一文快速了解什么是GIT

【GIT】：一文快速了解什么是GIT

【GIT】&#xff1a;一文快速了解什么是GIT 个人主页: 【⭐️个人主页】 需要您的【&#x1f496; 点赞关注】支持 &#x1f4af; 关于版本控制 什么是“版本控制”&#xff1f;我为什么要关心它呢&#xff1f; 版本控制是一种记录一个或若干文件内容变化&#xff0c;以便将来…
阅读更多...
使用数组实现队列

使用数组实现队列

目录 队列的应用场景 任务调度 广度优先搜索&#xff08;BFS&#xff09; 网络请求管理 消息队列 当我们在编写JavaScript代码时&#xff0c;经常会遇到需要使用队列的情况。队列是一种常见的数据结构&#xff0c;它按照先进先出&#xff08;First-In-First-Out&#xff0…
阅读更多...
【刷题篇】笔试真题

【刷题篇】笔试真题

文章目录 复数乘法一年中的第几天字符串相加字符串相乘 复数乘法 复数 可以用字符串表示&#xff0c;遵循 “实部虚部i” 的形式&#xff0c;并满足下述条件&#xff1a; 实部 是一个整数&#xff0c;取值范围是 [-100, 100] 虚部 也是一个整数&#xff0c;取值范围是 [-100, 1…
阅读更多...
ES6初步了解迭代器

ES6初步了解迭代器

迭代器是什么&#xff1f; 迭代器(iterator)是一种接口&#xff0c;为各种不同的数据结构提供统一的访问机制。任何数据结构只要部署 iterator 接口&#xff0c;就可以完成遍历操作 ES6创造了一种新的遍历方法for…of循环&#xff0c;iterator 接口主要供 for…of 使用 原生中具…
阅读更多...
docker、docker-compose安装教程，很详细

docker、docker-compose安装教程，很详细

docker、docker-compose安装教程&#xff0c;很详细 一、卸载旧版1、查看有没有安装过旧版2、停止docker3、删除安装过docker的相关包4、删除docker相关的镜像和容器 二、docker安装1、设置阿里云镜像2、查看所有docker3、安装最新版本4、安装指定版本 三、使用前准备1、启动do…
阅读更多...
第二证券：AIGC概念活跃，焦点科技、三维通信涨停，万兴科技大涨

第二证券：AIGC概念活跃，焦点科技、三维通信涨停，万兴科技大涨

AIGC概念24日盘中走势生动&#xff0c;到发稿&#xff0c;万兴科技、三态股份涨超10%&#xff0c;焦点科技、三维通讯、我国科传等涨停&#xff0c;中文在线涨超9%&#xff0c;果麦文明、新国都涨约7%。 消息面上&#xff0c;各大电商途径于10月18-24日先后发动“双11”大促或…
阅读更多...
FPGA驱动步进电机-Sin曲线加速

FPGA驱动步进电机-Sin曲线加速

FPGA驱动步进电机-Sin曲线加速 基本实现原理实际仿真的波形程序 以下由特权同学的FPGA文档摘取 Sin 曲线控制 step 脉冲信号生成的功能框图如下所示。 基本实现原理 ①判断步进电机驱动的目标频率 stepper_delay_target 与当前频率 stepper_delay_current的值是否一致&#…
阅读更多...
Java IDEA controller导出CSV，excel

Java IDEA controller导出CSV，excel

Java IDEA controller导出CSV&#xff0c;excel 导出excel/csv&#xff0c;亲测可共用一个方法&#xff0c;代码逻辑里判断设置不同的表头及contentType&#xff1b;导出excel导出csv 优化&#xff1a;有数据时才可以导出参考 导出excel/csv&#xff0c;亲测可共用一个方法&…
阅读更多...
【Jenkins 安装】

【Jenkins 安装】

一&#xff1a;安装文件夹准备 在/home/admin 界面下新建三个文件夹&#xff0c;用来安装tomcat、maven 1.打开&#xff0c;/home/admin目录 cd /home/admin 2.新建三个文件夹 mkdir tomcat mkdir maven 二&#xff1a;安装tomcat 1.打开tomcat目录进行tomcat的安装 访问:h…
阅读更多...
Xfigure综合膳食营养粉美丽上线，大健康行业竞争呈现多元化

Xfigure综合膳食营养粉美丽上线，大健康行业竞争呈现多元化

10月21日&#xff0c;“美丽健康 营养为先”2023全民营养健康科学论坛暨悦小妖2023秋季新品发布会在杭州召开&#xff0c;会上就当下的国民营养健康问题提出了许多建设性的观点&#xff0c;新发布的Xfigure是行业内少有的提倡营养为主的特膳类产品。 拥抱趋势&#xff0c;全新突…
阅读更多...
redis持久化之RDB（Redis DataBase）

redis持久化之RDB（Redis DataBase）

1 : 总体介绍 Redis是一个基于内存的数据库&#xff0c;它的数据是存放在内存中&#xff0c;内存有个问题就是关闭服务或者断电会丢 失。 Redis的数据也支持写到硬盘中&#xff0c;这个过程就叫做持久化 1.1 。 Redis提供了2种不同形式的持久化方式。 RDB&#xff08;Redis Da…
阅读更多...
uboot移植之DDR初始化参数更改说明

uboot移植之DDR初始化参数更改说明

一. 简介 裸机篇开发时&#xff0c;DDR初始化是 imxdownload软件完成的。imxdownload软件在 二进制文件 u-boot.bin 前面加上头部(IVT、DCD等数据)。这其中所加的头部信息就包括 DDR初始化内容。 u-boot.bin 就是编译出来的 uboot 二进制文件。 uboot 是个裸机程序&#x…
阅读更多...
JUnit5参数化测试的几种方式！

JUnit5参数化测试的几种方式！

参数化测试一直是津津乐道的话题&#xff0c;我们都知道JMeter有四种参数化方式&#xff1a;用户自定义变量、用户参数、CSV文件、函数助手&#xff0c;那么JUnit5有哪些参数化测试的方式呢&#xff1f; 依赖 JUnit5需要添加junit-jupiter-params依赖才能使用参数化&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023