1. Toy模板网首页
  2. > Toy博客

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

9月前 作者：小蜗牛~向前冲 分类：Toy博客 阅读(44) 违法举报

这篇具有很好参考价值的文章主要介绍了[数据结构]-二叉搜索树。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节作者：小蜗牛向前冲

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节名言：我可以接受失败，但我不能接受放弃

 如果觉的博主的文章还不错的话，还请[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正。

目录

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

1、什么是二叉搜索树

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

二、底层模拟实现

1、构建二叉搜索树

2、二叉搜索树的查找

3、二叉搜索树的插入

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

 5、完整代码实现

三、二叉搜索树的应用

1、K模型

2、KV模型

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

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

1、什么是二叉搜索树

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

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

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

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节

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

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

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

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

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

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节

  •  最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：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、二叉搜索树的查找

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

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节

查找原则：

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

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

普通写法：

//查找
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、二叉搜索树的插入

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节

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

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节

我们要找到插入的位置。然后在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指针的别名，就可以完美的连接起来。[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节

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

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

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

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

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

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节

  • 情况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;
		}
	}
}

[数据结构]-二叉搜索树,数据结构,算法,数据结构,c++,1024程序员节

这里我们对改造的二叉搜索树，就可以进行通过英文快速找到英文。文章来源地址https://www.toymoban.com/news/detail-718431.html

到了这里，关于[数据结构]-二叉搜索树的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 数据结构与算法之二叉树: Leetcode 98. 验证二叉搜索树 (Typescript版)

    验证二叉搜索树 https://leetcode.cn/problems/validate-binary-search-tree/ 描述 给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树 有效 二叉搜索树定义如下： 节点的左子树只包含 小于 当前节点的数。 节点的右子树只包含 大于 当前节点的数。 所有左子树和右子树自身

    2024年02月16日
    浏览(36)
  • 数据结构与算法（三）：树论（树形结构、二叉树、二叉搜索树、红黑树、Btree&B+Tree、赫夫曼树、堆树）

    数据结构与算法（三）：树论（树形结构、二叉树、二叉搜索树、红黑树、Btree&B+Tree、赫夫曼树、堆树）

    树论（树形结构、二叉树、二叉搜索树、红黑树、Btree、B+Tree、赫夫曼树、堆树） 在树形结构里面重要的术语： 结点：树里面的元素。 父子关系：结点之间相连的边 子树：当结点大于1时，其余的结点分为的互不相交的集合称为子树 度：一个结点拥有的子树数量称为结点的

    2024年02月01日
    浏览(93)
  • java数据结构与算法刷题-----LeetCode96. 不同的二叉搜索树

    java数据结构与算法刷题-----LeetCode96. 不同的二叉搜索树

    java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)： https://blog.csdn.net/grd_java/article/details/123063846 很多人觉得动态规划很难，但它就是固定套路而已。其实动态规划只不过是将多余的步骤，提前放到dp数组中（就是一个数组，只

    2024年01月21日
    浏览(52)
  • 数据结构——二叉搜索树

    数据结构——二叉搜索树

    本章代码:二叉搜索树 二叉搜索树又叫二叉排序树，它具有以下性质： 若左子树不为空，则左子树上所有结点的值都小于根结点的值 若右子树不为空，则右子树上所有结点的值都大于根结点的值 它的左右子树也分别为二叉搜索树 这个结构的时间复杂度为一般人会以为是 O(

    2024年02月12日
    浏览(39)
  • [数据结构]-二叉搜索树

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

    前言 作者 ： 小蜗牛向前冲 名言 ： 我可以接受失败，但我不能接受放弃   如果觉的博主的文章还不错的话，还请 点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正。 目录 一、二叉搜索树的基本知识 1、什么是二叉搜索树 2、二叉搜索树的性能

    2024年02月08日
    浏览(44)
  • 数据结构---二叉搜索树

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

    二叉搜索树(Binary Search Tree 简称BST)又称二叉排序树，是一种二叉树的特殊形式，它在每个节点上存储的键值满足以下性质： 若它的左子树不为空，则左子树上的所有节点的 值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也

    2024年02月07日
    浏览(40)
  • 【数据结构】二叉搜索树

    【数据结构】二叉搜索树

    二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 两种情况： 树为空，则

    2024年01月19日
    浏览(37)
  • 数据结构：搜索二叉树 | 平衡二叉树

    数据结构：搜索二叉树 | 平衡二叉树

    博客写的代码都放在这里：gitee仓库链接 1.二叉搜索树 1.1.基本概念 二叉搜索树又称二叉排序树， 可以为空，如果不为空具有以下性质的二叉树 : 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的

    2024年01月23日
    浏览(55)
  • 高级数据结构——二叉搜索树

    高级数据结构——二叉搜索树

    目录 1. 二叉搜索树的概念 2. 二叉搜索树的实现 结点类 二叉搜索树的类 2.1 默认成员函数 2.1.1 构造函数 2.1.2 拷贝构造函数 2.1.3 赋值运算符重载函数 2.1.4 析构函数 2.2 中序遍历 2.3 insert插入函数 2.3.1 非递归实现 2.3.2 递归实现 2.4 erase删除函数 2.4.1 非递归实现 2.4.2 递归版本

    2024年02月10日
    浏览(39)
  • 高级数据结构 ＜二叉搜索树＞

    高级数据结构 ＜二叉搜索树＞

    本文已收录至《数据结构(C/C++语言)》专栏！ 作者：ARMCSKGT 前面我们学习了二叉树，但仅仅只是简单的二叉树并没有很大的用处，而本节的二叉搜索树是对二叉树的升级，其查找效率相对于简单二叉树来说有一定提升，二叉搜索树是学习AVL树和红黑树的基础，所以我们必须先

    2024年02月04日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包