【C++】二叉搜索树

柔情只为你懂 2024-04-27 07:33 105阅读 0赞

#### 文章目录 ####

*  一、二叉搜索树的概念
 *  二、二叉搜索树的操作
 *   *  1. 二叉搜索树的查找
     *  2. 二叉搜索树的插入
     *  3. 二叉搜索树的删除
     *  4. 查找、插入、删除的递归实现
     *  5. 二叉搜索树整体代码
 *  三、 二叉搜索树的应用
 *  四、二叉树的性能分析

--------------------

## 一、二叉搜索树的概念 ##

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

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

![在这里插入图片描述][ac0915d13ae2423cb5dea73286c744f7.jpeg]

--------------------

## 二、二叉搜索树的操作 ##

**二叉搜索树的整体框架：**

### 1. 二叉搜索树的查找 ###

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

? **代码实现：**

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

--------------------

### 2. 二叉搜索树的插入 ###

插入的具体过程如下：

*  根为空，则直接新增节点，赋值给root指针
 *  根不为空，按二叉搜索树性质查找插入位置，插入新节点，这里我们在插入的过程中需要提前记录一下父节点的地址，因为要通过父节点将节点链接起来。

当根节点不为空时，又分为两种插入方式：

> (1) 如果要插入的值比根大就往右边走，比根小就往左边走。直到找到为空的位置，然后插入。  
> (2) 如果查找过程中遇到与要插入节点相同的节点，直接返回false，因为K模型中不允许出现key值相同的节点。

![在这里插入图片描述][e72b81cd77c54cddac45fb9c88a5995a.jpeg]

? **代码实现：**

bool Insert(const K& key)
    {
        
    	//根节点为空的情况
    	if (_root == nullptr) {
        
    		_root = new Node(key);
    		return true;
    	}
    	//根节点不为空的情况
    	Node* cur = _root;
    	Node* parent = nullptr;
    	while (cur)
    	{
        
    		if (key > cur->_key) {
        
    			parent = cur;
    			cur = cur->_right;
    		}
    		else if (key < cur->_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;
    }

--------------------

### 3. 二叉搜索树的删除 ###

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

>  *  情况1：删除的节点为叶子节点，此时我们只需要让父节点的 left/right 指向空，然删除掉叶子节点即可——直接删除。
>  *  情况2：删除的节点只有左孩子或者只有右孩子，此时我们需要将该节点的子节点托孤给父节点，然后再删除掉该节点——直接删除。
>  *  情况3：要删除的节点既有左孩子又有右孩子，此时我们需要先将该节点与左子树的最大值/最右节点或者右子树的最小/最左节点进行交换，然后再delete掉被替换的最左节点/最右节点——替换删除。

当然了，这里的情况1可以归纳到情况2中，因为左右都为空也属于左为空或者右为空的情况。

? **左为空或者右为空的情况：**

![在这里插入图片描述][048ad1e04324481792dd5cb5eba67a32.png]

? **左右孩子都不为空的情况：**

![在这里插入图片描述][70a66bbb7e4a4cfa928f9038cd11f7a0.png]

这里我们还需要注意一个细节：

> 如果右孩子或者左孩子为空，且要删除的节点是根节点时，需要特殊判断一下，直接让根节点指向左孩子或者右孩子即可。否则的话就会对根节点进行解引用，程序发生奔溃。

? **代码实现：**

bool Erase(const K& key)
    {
        
    	Node* parent = nullptr;
    	Node* cur = _root;
    	while (cur)
    	{
        
    		if (key > cur->_key) {
        
    			parent = 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;
    				}
    				else
    				{
        
    					if (parent->_right == cur) {
        
    						parent->_right = cur->_right;
    					}
    					else {
        
    						parent->_left = cur->_right;
    					}
    				}
    				delete cur;
    			}
    			//2. 删除操作——右孩子为空
    			else if (cur->_right == nullptr)
    			{
        
    				if (cur == _root)
    				{
        
    					_root = cur->_left;
    				}
    				else
    				{
        
    					if (parent->_right == cur) {
        
    						parent->_right = cur->_left;
    					}
    					else {
        
    						parent->_left = cur->_left;
    					}
    				}
    				delete cur;
    			}
    			//两个孩子都不为空
    			else
    			{
        
    				//3.其他情况该如何办呢？——找右树最小节点或者左树最大节点来代替
    				Node* minRight = cur->_right;
    				Node* pminRight = cur;
    				while (minRight->_left)
    				{
        
    					pminRight = minRight;
    					minRight = minRight->_left;
    				}
    				cur->_key = minRight->_key;
    				if (pminRight->_right == minRight) {
        
    					pminRight->_right = minRight->_right;
    				}
    				else {
        
    					pminRight->_left = minRight->_right;
    				}
    				delete minRight;//这里我们要注意删除的节点是minRight而不是cur否则程序会奔溃
    			}
    			return true;
    		}
    	}
    	return false;
    }

--------------------

### 4. 查找、插入、删除的递归实现 ###

? **查找递归实现**

//递归查询
    bool FindR(const K& key)
    {
        
    	return _FindR(_root, key);
    }
    //查找递归方法
    bool _FindR(Node* root, const K& key)
    {
        
    	if (root == nullptr)
    		return false;
    
    	else if (key > root->_key)
    		return _FindR(root->_right, key);
    	else if (key < root->_key)
    		return _FindR(root->_left, key);
    	else
    		return true;
    }

? **插入递归实现**

//递归插入
    bool InsertR(const K& key)
    {
        
    	return _InsertR(_root, key);
    }
    //插入递归方法
    bool _InsertR(Node*& root, const K& key)
    {
        
    	if (root == nullptr) {
        
    		root = new Node(key);
    		return true;
    	}
    	if (key > root->_key) {
        
    		return _InsertR(root->_right, key);
    	}
    	else if (key < root->_key) {
        
    		return _InsertR(root->_left, key);
    	}
    	else {
        
    		return false;
    	}
    }

? **删除递归实现**

//递归删除
    bool EraseR(const K& key)
    {
        
    	return _EraseR(_root, key);
    }
    //删除递归方法
    bool _EraseR(Node*& root, const K& key)
    {
        
    	if (root == nullptr)
    		return false;
    	if (key > root->_key) {
        
    		return _EraseR(root->_right, key);
    	}
    	else if (key < root->_key) {
        
    		return _EraseR(root->_left, key);
    	}
    	else
    	{
        
    		//正式开始删除操作
    		Node* del = root;   //先保存根节点以便于后续删除
    
    		//1.左孩子为空
    		if (root->_left == nullptr) {
        
    			root = root->_right;
    		}
    		//2.右孩子为空
    		else if (root->_right == nullptr) {
        
    			root = root->_left;
    		}
    		//3.两个孩子都不为空——难点哦!
    		else
    		{
        
    			//找左子树的最大值来替代待删除的节点
    			Node* leftMax = root->_left;
    			while (leftMax->_right)
    			{
        
    				leftMax = leftMax->_right;
    			}
    			//交换两个节点的key值
    			swap(root->_key, leftMax->_key);
    			return _EraseR(root->_left, key);
    		}
    		delete del;
    		return true;
    	}
    }

**当左孩子为空或者右孩子为空时**，因此此时的root是其父节点左指针或者右指针的别名，因此我们只需要改变root的指向，`root = root->_left 或者 root = root->_right`，就可以改变父节点左指针或者右指针的指向。

**当左孩子和右孩子都不为空时**，我们可以找左子树的最右节点或者右子树的最左节点，这里我们以左子树的最左节点为例。将该节点的Key值和要删除的节点的Key值进行交换，然后再调用`_EraseR(root->_left, key);`删除替换后的节点即可。

![在这里插入图片描述][3d544a434f36413f98f709a7e6bcecdc.png]

--------------------

### 5. 二叉搜索树整体代码 ###

//节点的定义
    template<class K>
    struct BSTreeNode {
        
    	BSTreeNode<K>* _left;//左孩子
    	BSTreeNode<K>* _right;//右孩子
    	K _key;//节点数据
    	//构造函数
    	BSTreeNode(const K& key)
    		:_left(nullptr)
    		, _right(nullptr)
    		, _key(key)
    	{
        }
    };
    
    //二叉搜索树的类模板定义
    template<class K>
    class BSTree
    {
        
    	typedef BSTreeNode<K> Node;
    public:
    	BSTree() = default;//强制生成默认构造函数
    
    	//拷贝构造函数
    	BSTree(const BSTree<K>& b)
    	{
        
    		_root = Copy(b._root);
    	}
    
    	//赋值运算符重载函数
    	BSTree<K>& operator=(BSTree<K> k)
    	{
        
    		swap(_root, k._root);
    		return *this;
    	}
    
    	//析构函数
    	~BSTree()
    	{
        
    		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 (key > cur->_key) {
        
    				parent = cur;
    				cur = cur->_right;
    			}
    			else if (key < cur->_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 (key > cur->_key) {
        
    				cur = cur->_right;
    			}
    			else if (key < cur->_key) {
        
    				cur = cur->_left;
    			}
    			else {
        
    				return true;
    			}
    		}
    		return false;
    	}
    
    	//二叉树的删除操作
    	bool Erase(const K& key)
    	{
        
    		Node* parent = nullptr;
    		Node* cur = _root;
    		while (cur)
    		{
        
    			if (key > cur->_key) {
        
    				parent = 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;
    					}
    					else
    					{
        
    						if (parent->_right == cur) {
        
    							parent->_right = cur->_right;
    						}
    						else {
        
    							parent->_left = cur->_right;
    						}
    					}
    					delete cur;
    				}
    				//2. 删除操作——右孩子为空
    				else if (cur->_right == nullptr)
    				{
        
    					if (cur == _root)
    					{
        
    						_root = cur->_left;
    					}
    					else
    					{
        
    						if (parent->_right == cur) {
        
    							parent->_right = cur->_left;
    						}
    						else {
        
    							parent->_left = cur->_left;
    						}
    					}
    					delete cur;
    				}
    				//两个孩子都不为空
    				else
    				{
        
    					//3.其他情况该如何办呢？——找右树最小节点或者左树最大节点来代替
    					Node* minRight = cur->_right;
    					Node* pminRight = cur;
    					while (minRight->_left)
    					{
        
    						pminRight = minRight;
    						minRight = minRight->_left;
    					}
    					cur->_key = minRight->_key;
    					if (pminRight->_right == minRight) {
        
    						pminRight->_right = minRight->_right;
    					}
    					else {
        
    						pminRight->_left = minRight->_right;
    					}
    					delete minRight;//这里我们要注意删除的节点是minRight而不是cur否则程序会奔溃
    				}
    				return true;
    			}
    		}
    		return false;
    	}
    
    	//搜索二叉树的中序遍历——这儿需要注意_root和root的名字不要搞混，不然程序会奔溃
    	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:
    	//拷贝函数
    	Node* Copy(Node* root)
    	{
        
    		//先将每一个节点拷贝出来，最后递归结束的时候在依次链接起来
    		if (root == nullptr)
    			return nullptr;
    		Node* cur = new Node(root->_key);
    		cur->_left = Copy(root->_left);
    		cur->_right = Copy(root->_right);
    		return cur;
    	}
    	//释放内存函数——后续遍历删除
    	void Destroy(Node*& root)
    	{
        
    		if (root == nullptr)
    			return;
    		Destroy(root->_left);
    		Destroy(root->_right);
    		delete root;
    		root = nullptr;
    	}
    	//中序遍历
    	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 (key > root->_key) {
        
    			return _InsertR(root->_right, key);
    		}
    		else if (key < root->_key) {
        
    			return _InsertR(root->_left, key);
    		}
    		else {
        
    			return false;
    		}
    	}
    	//查找递归方法
    	bool _FindR(Node* root, const K& key)
    	{
        
    		if (root == nullptr)
    			return false;
    
    		else if (key > root->_key)
    			return _FindR(root->_right, key);
    		else if (key < root->_key)
    			return _FindR(root->_left, key);
    		else
    			return true;
    	}
    	//删除递归方法
    	bool _EraseR(Node*& root, const K& key)
    	{
        
    		if (root == nullptr)
    			return false;
    		if (key > root->_key) {
        
    			return _EraseR(root->_right, key);
    		}
    		else if (key < root->_key) {
        
    			return _EraseR(root->_left, key);
    		}
    		else
    		{
        
    			//正式开始删除操作
    			Node* del = root;   //先保存根节点以便于后续删除
    
    			//1.左孩子为空
    			if (root->_left == nullptr) {
        
    				root = root->_right;
    			}
    			//2.右孩子为空
    			else if (root->_right == nullptr) {
        
    				root = root->_left;
    			}
    			//3.两个孩子都不为空——难点哦!
    			else
    			{
        
    				//找左子树的最大值来替代待删除的节点
    				Node* leftMax = root->_left;
    				while (leftMax->_right)
    				{
        
    					leftMax = leftMax->_right;
    				}
    				//交换两个节点的key值
    				swap(root->_key, leftMax->_key);
    				return _EraseR(root->_left, key);
    			}
    			delete del;
    			return true;
    		}
    	}
    private:
    	//根节点
    	Node* _root = nullptr;
    };

--------------------

## 三、 二叉搜索树的应用 ##

1.  **K模型：** K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到  
    的值。  
    比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树，在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
2.  **KV模型：** 每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：  
    比如：英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文 **<word, chinese>** 就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。

**`例如：`**

? **统计每种水果出现的次数：**

namespace KeyVal
    {
        
    	//节点的定义
    	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* cur = _root;
    			Node* parent = nullptr;
    			while (cur)
    			{
        
    				if (key > cur->_key) {
        
    					parent = cur;
    					cur = cur->_right;
    				}
    				else if (key < cur->_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 (key > cur->_key) {
        
    					cur = cur->_right;
    				}
    				else if (key < cur->_key) {
        
    					cur = cur->_left;
    				}
    				else {
        
    					return cur;
    				}
    			}
    			return nullptr;
    		}
    
    		//二叉树的删除操作
    		bool Erase(const K& key)
    		{
        
    			Node* parent = nullptr;
    			Node* cur = _root;
    			while (cur)
    			{
        
    				if (key > cur->_key) {
        
    					parent = 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;
    						}
    						else
    						{
        
    							if (parent->_right == cur) {
        
    								parent->_right = cur->_right;
    							}
    							else {
        
    								parent->_left = cur->_right;
    							}
    						}
    						delete cur;
    					}
    					//2. 删除操作——右孩子为空
    					else if (cur->_right == nullptr)
    					{
        
    						if (cur == _root)
    						{
        
    							_root = cur->_left;
    						}
    						else
    						{
        
    							if (parent->_right == cur) {
        
    								parent->_right = cur->_left;
    							}
    							else {
        
    								parent->_left = cur->_left;
    							}
    						}
    						delete cur;
    					}
    					//两个孩子都不为空
    					else
    					{
        
    						//3.其他情况该如何办呢？——找右树最小节点或者左树最大节点来代替
    						Node* minRight = cur->_right;
    						Node* pminRight = cur;
    						while (minRight->_left)
    						{
        
    							pminRight = minRight;
    							minRight = minRight->_left;
    						}
    						cur->_key = minRight->_key;
    						if (pminRight->_right == minRight) {
        
    							pminRight->_right = minRight->_right;
    						}
    						else {
        
    							pminRight->_left = minRight->_right;
    						}
    						delete minRight;//这里我们要注意删除的节点是minRight而不是cur否则程序会奔溃
    					}
    					return true;
    				}
    			}
    			return false;
    		}
    
    		//搜索二叉树的中序遍历——这儿需要注意_root和root的名字不要搞混，不然程序会奔溃
    		void InOrder()
    		{
        
    			_InOrder(_root);
    			cout << endl;
    		}
    	protected:
    		//中序遍历
    		void _InOrder(Node* root)
    		{
        
    			if (root == nullptr)
    				return;
    			_InOrder(root->_left);
    			cout << root->_key << ":" << root->_val << endl;
    			_InOrder(root->_right);
    		}
    	private:
    		//根节点
    		Node* _root = nullptr;
    	};
    }

//test.cpp
    void TestBSTree4()
    {
        
    	string arr[] = {
         "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨" };
    	KeyVal::BSTree<string, int> bs;
    	for (auto e : arr)
    	{
        
    		auto ret = bs.Find(e);
    		if (ret == nullptr)
    			bs.Insert(e, 1);
    		else
    			ret->_val++;
    	}
    	bs.InOrder();
    }

![在这里插入图片描述][e90acb6015e343b7998a64a84007a75a.png]

--------------------

## 四、二叉树的性能分析 ##

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

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

![在这里插入图片描述][167c11e139a94171814640f1f7420058.png]

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

>  *  最优情况下，二叉搜索树为完全二叉树 (或者接近完全二叉树)，其平均比较次数为 O(logN)。
>  *  最差情况下，二叉搜索树退化为单支树( 或者类似单支)，其平均比较次数为 O(N)。

只有当数据有序或接近有序时二叉搜索树查找数据的时间复杂度才为 O(N)，大部分情况下查找效率都是要远高于 O(N) 的；同时，在实际开发中我们用的并不是单纯的二叉搜索树树，而是它的改进版 – 二叉搜索平衡树 (AVL树) ，即插入数据后对二叉搜索树进行调整，让其左右子树尽量变得平衡，这样，二叉搜索树的查找效率就几乎等于 O(logN) 了。

--------------------

[ac0915d13ae2423cb5dea73286c744f7.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/9061c4ba40e1489fafd6e8946b9523db.jpeg
[e72b81cd77c54cddac45fb9c88a5995a.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/a1908252621c430bb711e6f411569c99.jpeg
[048ad1e04324481792dd5cb5eba67a32.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/2eef3624587d4104b736444d61b12d1c.png
[70a66bbb7e4a4cfa928f9038cd11f7a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/061af42e773a449cb8316d2b4e4f937b.png
[3d544a434f36413f98f709a7e6bcecdc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/dd0ec380a3ee4f19afb5460703aa7ce5.png
[e90acb6015e343b7998a64a84007a75a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/797b55ca49f940b9a38c424adbdbb329.png
[167c11e139a94171814640f1f7420058.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/f4ddee5a2a6e44b9a56a4d72d9691e04.png