⼆叉搜索树详解

news2025/5/21 5:41:32

在这里插入图片描述1. ⼆叉搜索树的概念
⼆叉搜索树⼜称⼆叉排序树，它或者是⼀棵空树，或者是具有以下性质的⼆叉树:
• 若它的左⼦树不为空，则左⼦树上所有结点的值都⼩于等于根结点的值
• 若它的右⼦树不为空，则右⼦树上所有结点的值都⼤于等于根结点的值
• 它的左右⼦树也分别为⼆叉搜索树
• ⼆叉搜索树中可以⽀持插⼊相等的值，也可以不⽀持插⼊相等的值，具体看使⽤场景定义，后续我们学习map/set/multimap/multiset系列容器底层就是⼆叉搜索树，其中map/set不⽀持插⼊相等值，multimap/multiset⽀持插⼊相等值
称为二叉排序树的原因：这颗树是严格遵守左边小右边大的方式.当我们去按中序遍历去走一边,它就会排好升序,所以叫二叉排序树。
在这里插入图片描述
2. ⼆叉搜索树的性能分析
最优情况下，⼆叉搜索树为完全⼆叉树(或者接近完全⼆叉树)，其⾼度为： log2 N最差情况下，⼆叉搜索树退化为单⽀树(或者类似单⽀)，其⾼度为： N
所以综合⽽⾔⼆叉搜索树增删查改时间复杂度为： O(N)
那么这样的效率显然是⽆法满⾜我们需求的，我们后续课程需要继续讲解⼆叉搜索树的变形，平衡⼆叉搜索树AVL树和红⿊树，才能适⽤于我们在内存中存储和搜索数据。
另外需要说明的是，⼆分查找也可以实现 O(log2 N) 级别的查找效率，但是⼆分查找有两⼤缺陷：
3. 需要存储在⽀持下标随机访问的结构中，并且有序。
4. 插⼊和删除数据效率很低，因为存储在下标随机访问的结构中，插⼊和删除数据⼀般需要挪动数据。
这⾥也就体现出了平衡⼆叉搜索树的价值。
在这里插入图片描述
3.二叉搜索树相关功能实现
初始化，insert(插入)，Find(查找)，Erase(删除)，析构，打印(中序遍历)，构造(深拷贝)

初始化

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:

private:
Node* _root=nullptr;

insert(插入)
在这里插入图片描述

//不带重复的搜索二叉树
//插入
bool Insert(const K& key)
{
	//如果为第一个节点，直接创建新节点赋予_root
	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所在位置即为插入点
	//创建出节点+真确链接(判断出为parent左边还是右边)
	cur = new Node(key);
	if (parent->_key < key)
	{
		parent->right = cur;
	}
	else
	{
		parent->left = cur;
	}

	return true;

}

其中while那部分代码为核心，利用二叉搜索树左边小·右边大特性找到插入节点位置。

Find(查找)
关键代码(while利用二叉搜索树特性寻找)

bool Find(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
		{
			//已存在这种值到达此处
			return true;
		}
	}
	return false;
}

Erase(删除)
⾸先查找元素是否在⼆叉搜索树中，如果不存在，则返回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，可以直接删除。
    采用替换法，然后删除情况会变成1，2，3进行操作
    细节:删除节点要判断为，parent的左，还是parent的右。经过分析为parent左为一般情况，parent的右删除节点为根节点。
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->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//到达这里为左右孩子都存在
			{
				//替换法
				Node* pMinright = cur;
				Node* minRight = cur->right;
				while (minRight->left)
				{
					pMinright = minRight;
					minRight = minRight->left;
				}
				swap(cur->_key, minRight->_key);
				//删除节点要判断为，parent的左，还是parent的右
				if (pMinright->left == minRight)
				{
					pMinright->left = minRight->right;
				}
				else
				{
					pMinright->right = minRight->right;
				}
				delete minRight;
			}
			return true;
		}
	}
	return false;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
打印(中序遍历)，构造(深拷贝)，析构
1.分析知道，递归遍历需要传入根节点参数，如果由使用者传入根节点是不方便的，因为_root为private不便于访问，解决方案1.成员函数GetRoot（）将遍历包裹一层，具体实现看代码
2.深拷贝利用前序遍历一个个取值构造
3.析构利用后序遍历

public:
	//默认构造函数
	//方法一
	/*BSTree()
	{

	}*/
	//方法二 强制生成
	BSTree() = default;

	//拷贝构造
	BSTree(const BSTree<K>& t)
	{
		//这种写法肯定存在问题这是一种浅拷贝，通过析构来观察
		//_root = t._root;

		//完成深拷贝就要利用t给*this构造
		_root = Copy(t._root);

	}
	//赋值运算符重载
	BSTree<K>& operator=(const BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

~BSTree()
{
	Destory(_root);
}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->left);
		cout << root->_key << " ";
		_InOrder(root->right);
	}

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

		Node* copy = new Node(root->_key);
		copy->left = Copy(root->left);
		copy->right = Copy(root->right);

		return copy;
	}

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

		Destory(root->left);
		Destory(root->right);
		delete root;
	}

二叉搜索树的key/key-value的实现场景
1 key搜索场景：
只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，搜索场景只需要判断key在不在。key的搜索场景实现的⼆叉树搜索树⽀持增删查，但是不⽀持修改，修改key破坏搜索树结构了。
场景1：⼩区⽆⼈值守⻋库，⼩区⻋库买了⻋位的业主⻋才能进⼩区，那么物业会把买了⻋位的业主的⻋牌号录⼊后台系统，⻋辆进⼊时扫描⻋牌在不在系统中，在则抬杆，不在则提⽰⾮本⼩区⻋辆，⽆法进⼊。
场景2：检查⼀篇英⽂⽂章单词拼写是否正确，将词库中所有单词放⼊⼆叉搜索树，读取⽂章中的单词，查找是否在⼆叉搜索树中，不在则波浪线标红提⽰。

2.key/value搜索场景：
每⼀个关键码key，都有与之对应的值value，value可以任意类型对象。树的结构中(结点)除了需要存储key还要存储对应的value，增/删/查还是以key为关键字⾛⼆叉搜索树的规则进⾏⽐较，可以快速查找到key对应的value。key/value的搜索场景实现的⼆叉树搜索树⽀持修改，但是不⽀持修改key，修改key破坏搜索树性质了，可以修改value。
场景1：简单中英互译字典，树的结构中(结点)存储key(英⽂)和vlaue(中⽂)，搜索时输⼊英⽂，则同时查找到了英⽂对应的中⽂。
场景2：商场⽆⼈值守⻋库，⼊⼝进场时扫描⻋牌，记录⻋牌和⼊场时间，出⼝离场时，扫描⻋牌，查找⼊场时间，⽤当前时间-⼊场时间计算出停⻋时⻓，计算出停⻋费⽤，缴费后抬杆，⻋辆离场。
场景3：统计⼀篇⽂章中单词出现的次数，读取⼀个单词，查找单词是否存在，不存在这个说明第⼀次出现，（单词，1），单词存在，则++单词对应的次数。

代码实现

namespace key_value
{
	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)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _value(value)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		// 强制生成
		BSTree() = default;

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

		// t1 = t3
		// BSTree& operator=(BSTree t)
		BSTree<K, V>& operator=(BSTree<K, V> t)
		{
			swap(_root, t._root);

			return *this;
		}

		~BSTree()
		{
			Destory(_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 (parent == 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 // 两个孩子
					{
						Node* pMinRight = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							pMinRight = minRight;
							minRight = minRight->_left;
						}

						swap(cur->_key, minRight->_key);
						if (pMinRight->_left == minRight)
						{
							pMinRight->_left = minRight->_right;
						}
						else
						{
							pMinRight->_right = minRight->_right;
						}

						delete minRight;
					}

					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 Destory(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

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

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

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

			return copy;
		}

	private:
		Node* _root = nullptr;
	};
}

在这里插入图片描述

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

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

相关文章

如何使用通义灵码提高前端开发效率

如何使用通义灵码提高前端开发效率

工欲善其事&#xff0c;必先利其器。对于前端开发而言&#xff0c;使用VSCode已经能够极大地提高前端的开发效率了。但有了AI加持后&#xff0c;前端开发的效率又更上一层楼了&#xff01; 本文采用的AI是通义灵码插件提供的通义千问大模型&#xff0c;是目前AI性能榜第一梯队…
阅读更多...
Android Studio Kotlin 中的方法添加灰色参数提示

Android Studio Kotlin 中的方法添加灰色参数提示

在使用 Android Studio 时&#xff0c; 我发现使用 Java 编写方法后在调用方法时&#xff0c; 会自动显示灰色的参数。 但在 Kotlin 中没有显示&#xff0c; 于是找了各种方法最后找到了设置&#xff0c; 并且以本文章记录下来。 博主博客 https://blog.uso6.comhttps://blog.…
阅读更多...
TCP协议简介

TCP协议简介

TCP 协议 TCP&#xff08;Transmission Control Protocol&#xff0c;传输控制协议&#xff09;是互联网协议套件中的核心协议之一&#xff0c;位于传输层。它提供了一种可靠的、面向连接的、基于字节流的数据传输服务。TCP 的主要特点是确保数据在传输过程中不丢失、不重复&a…
阅读更多...
Linux学习心得问题整理（二）

Linux学习心得问题整理（二）

day05 Linux基础入门 Linux语法解析 如何理解ssh远程连接?如何使用ssh使用远程连接服务&#xff1f; ssh进也称远程服务终端&#xff0c;常见连接方式可以包括windows和Linux两种方式 首先咱们使用windows窗口进行连接&#xff0c;这里就采用xshell连接工具来给大家做演示吧…
阅读更多...
SOC-ESP32S3部分：2-2-VSCode进行编译烧录

SOC-ESP32S3部分：2-2-VSCode进行编译烧录

飞书文档https://x509p6c8to.feishu.cn/wiki/CTzVw8p4LiaetykurbTciA42nBf?fromScenespaceOverview 无论是使用Window搭建IDF开发环境&#xff0c;还是使用Linux Ubuntu搭建IDF开发环境&#xff0c;我们都建议使用VSCode进行代码编写和编译&#xff0c;VSCode界面友好&#x…
阅读更多...
Python虚拟环境再PyCharm中自由切换使用方法

Python虚拟环境再PyCharm中自由切换使用方法

Python开发中的环境隔离是必不可少的步骤，通过使用虚拟环境可以有效地管理不同项目间的依赖，避免包冲突和环境污染。虚拟环境是Python官方提供的一种独立运行环境，每个项目可以拥有自己单独的环境，不同项目之间的环境互不影响。在日常开发中，结合PyCharm这样强大的IDE进行…
阅读更多...
使用Mathematica绘制一类矩阵的特征值图像

使用Mathematica绘制一类矩阵的特征值图像

学习过线性代数的&#xff0c;都知道&#xff1a;矩阵的特征值非常神秘&#xff0c;但却携带着矩阵的重要信息。 今天&#xff0c;我们将展示&#xff1a;一类矩阵&#xff0c;其特征值集体有着很好的分布特征。 modifiedroots[c_List] : Block[{a DiagonalMatrix[ConstantAr…
阅读更多...
SpringBoot-6-在IDEA中配置SpringBoot的Web开发测试环境

SpringBoot-6-在IDEA中配置SpringBoot的Web开发测试环境

文章目录 1 环境配置1.1 JDK1.2 Maven安装配置1.2.1 安装1.2.2 配置1.3 Tomcat1.4 IDEA项目配置1.4.1 配置maven1.4.2 配置File Encodings1.4.3 配置Java Compiler1.4.4 配置Tomcat插件2 Web开发环境2.1 项目的POM文件2.2 项目的主启动类2.3 打包为jar或war2.4 访问测试3 附录3…
阅读更多...
基于springboot+vue的病例管理系统

基于springboot+vue的病例管理系统

开发语言&#xff1a;Java框架&#xff1a;springbootJDK版本&#xff1a;JDK1.8服务器&#xff1a;tomcat7数据库&#xff1a;mysql 5.7数据库工具&#xff1a;Navicat12开发软件&#xff1a;eclipse/myeclipse/ideaMaven包&#xff1a;Maven3.3.9 系统展示 患者信息管理 医…
阅读更多...
SpringBoot（三）--- 数据库基础

SpringBoot（三）--- 数据库基础

目录 前言 一、MySQL 1. 关系型数据库 2.数据模型 二、SQL语句 1.DDL语句 1.1 数据库操作 1.1.1 查询数据库 1.1.2 创建数据库 1.1.3 使用数据库 1.1.4 删除数据库 1.2 表操作 1.2.1 创建表 1.2.2 约束 1.2.3 数据类型 2.DML语句 2.1 增加&#xff08;insert&…
阅读更多...
【漫话机器学习系列】268. K 折交叉验证（K-Fold Cross-Validation）

【漫话机器学习系列】268. K 折交叉验证（K-Fold Cross-Validation）

图解 K 折交叉验证&#xff08;K-Fold Cross-Validation&#xff09;| 原理 数学公式 实践应用 原图作者&#xff1a;Chris Albon&#xff0c;手绘风格清晰易懂&#xff0c;本文基于其图解做详细扩展&#xff0c;适用于机器学习、深度学习初学者及进阶者参考学习。 一、什么是…
阅读更多...
【学习心得】Jupyter 如何在conda的base环境中其他虚拟环境内核

【学习心得】Jupyter 如何在conda的base环境中其他虚拟环境内核

如果你在conda的base环境运行了jupyter lab打开了一个ipynb文本&#xff0c;此时选择的内核是base虚拟环境的Python内核&#xff0c;如果我想切换成其他conda虚拟环境来运行这个文件该怎么办&#xff1f;下面我们试着还原一下问题&#xff0c;并且解决问题。 【注】 这个问题出…
阅读更多...
【Boost搜索引擎】构建Boost站内搜索引擎实践

【Boost搜索引擎】构建Boost站内搜索引擎实践

目录 1. 搜索引擎的相关宏观原理 2. 正排索引 vs 倒排索引 - 搜索引擎具体原理 3. 编写数据去标签与数据清洗的模块 Parser 去标签 编写parser 用boost枚举文件名 解析html 提取title ​编辑 去标签 构建URL 将解析内容写入文件中 4. 编写建立索引的模块 Index 建…
阅读更多...
Nginx配置记录访问信息

Nginx配置记录访问信息

文章目录 方法一&#xff1a;使用Nginx原生配置记录访问信息方法二&#xff1a;使用Nginx_headers_more模块记录更加详细的信息 Nginx被广泛应用于各种场景如&#xff1a;Web服务器、反向代理服务器、负载均衡器、Web应用防火墙(WAF)等 在实际的产品开发中&#xff0c;无论是功…
阅读更多...
HomeAssistant开源的智能家居docker快速部署实践笔记（CentOS7）

HomeAssistant开源的智能家居docker快速部署实践笔记（CentOS7）

1. SGCC_Electricity 应用介绍 SGCC_Electricity 是一个用于将国家电网&#xff08;State Grid Corporation of China&#xff0c;简称 SGCC&#xff09;的电费和用电量数据接入 Home Assistant 的自定义集成组件。通过该应用&#xff0c;用户可以实时追踪家庭用电量情况&…
阅读更多...
JAVA EE(进阶)_HTML

JAVA EE(进阶)_HTML

思如云烟&#xff0c;行若磐石。 ——陳長生. ❀主页&#xff1a;陳長生.-CSDN博客❀ &#x1f4d5;上一篇&#xff1a;JAVA EE&#xff08;进阶&#xff09;_进阶的开端-CSDN博客 1.HTML HTML&#xff08;HyperText Mark…
阅读更多...
职坐标AIoT技能培训课程实战解析

职坐标AIoT技能培训课程实战解析

职坐标AIoT技能培训课程以人工智能与物联网技术深度融合为核心&#xff0c;构建了“理论实战行业应用”三位一体的教学体系。课程体系覆盖Python编程基础、传感器数据采集、边缘计算开发、云端服务部署及智能硬件开发全链路&#xff0c;通过分层递进的知识模块帮助学员建立系统…
阅读更多...
8-游戏详情制作（Navigation组件）

8-游戏详情制作（Navigation组件）

1.1 需求 使用Navigation实现游戏主详情视图&#xff0c;从瀑布流容器中的游戏项&#xff08;游戏中心首页-游戏瀑布流列表&#xff09;点击游戏后进入游戏详情页&#xff0c;从游戏详情页可以返回游戏列表主页。 1.2 界面原型 从瀑布流组件进入&#xff1a; 游戏详情&#…
阅读更多...
Unity引擎源码-物理系统详解-其二

Unity引擎源码-物理系统详解-其二

继续我们关于Unity的物理系统的源码阅读&#xff0c;不过这一次我们的目标是PhysX引擎——这个Unity写了一堆脚本来调用API的实际用C写成的底层物理引擎。 Github的地址如下&#xff1a;NVIDIA-Omniverse/PhysX: NVIDIA PhysX SDK (github.com) 下载后发现由三个文件组成&…
阅读更多...
1.3.3 数据共享、汇聚和使用中的安全目标

1.3.3 数据共享、汇聚和使用中的安全目标

探索数据共享、汇聚与使用中的安全目标 在当今数字化时代&#xff0c;数据的价值愈发凸显&#xff0c;数据共享、汇聚与使用成为了推动业务发展、促进创新的重要环节。然而&#xff0c;在这一过程中&#xff0c;数据安全至关重要&#xff0c;我们需要明确并保障保密性、完整性…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023