【C++进阶】二叉搜索树

╰+攻爆jí腚メ 2024-04-26 11:01 4阅读 0赞

![在这里插入图片描述][6ac7346dc5944908b5dd227e55fab217.gif_pic_center]

> 🚀write in front🚀  
> 📜所属专栏： [C++学习][C]  
> 🛰️博客主页：[睿睿的博客主页][Link 1]  
> 🛰️代码仓库：🎉[VS2022\_C语言仓库][VS2022_C]  
> 🎡您的点赞、关注、收藏、评论，是对我最大的激励和支持！！！  
> **关注我，关注我，关注我**，你们将会看到更多的优质内容！！

![在这里插入图片描述][85d8f838a7524c8bb8bed80b7ac059c1.gif_pic_center]

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

*  前言
 *  一.概念：
 *  二.二叉树的实现
 *   *  1.0版本（循环版本）：
     *   *  1. 二叉搜索树的查找
         *  2. 二叉搜索树的插入
         *  3. 二叉搜索树的删除
     *  2.0版本（递归版本）
 *  三.搜索二叉树的应用：
 *  总结

## 前言 ##

## 一.概念： ##

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

*  **若它的左子树不为空，则左子树上所有节点的值都小于根节点的值**
 *  **若它的右子树不为空，则右子树上所有节点的值都大于根节点的值**
 *  它的**左右子树也分别为二叉搜索树**  
    ![在这里插入图片描述][56d2c5a7dec74d2780df290907024765.png]

## 二.二叉树的实现 ##

### 1.0版本（循环版本）： ###

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

a、从根开始比较，查找，由二叉搜索树的性质可知，比根大则往右边走查找，比根小则往左边走查找。  
b、最多查找高度次，走到到空，还没找到，这个值不存在。

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

插入的具体过程如下：  
a. **树为空**，则直接新增节点，赋值给root指针  
b. **树不空**，按二叉搜索树性质查找插入位置，插入新节点（这里的插入都是指的插在树叶的后面）

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

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：  
a. 要删除的结点无孩子结点  
b. 要删除的结点只有左孩子结点  
c. 要删除的结点只有右孩子结点  
d. 要删除的结点有左、右孩子结点  
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

1.  先找到要删除的结点和其父节点
2.  找到之后分两种情况：  
    a.删除结点有一个孩子或没有孩子：

*  左为空：  
    a1.父节点和删除结点如果重合，直接让root指向删除结点的右边  
    ![78dfb7c980c64eed9c29ffcb0bd7e270.png][]
    
    a2父节点指向删除结点的右边  
    ![在这里插入图片描述][4a24462983874a0881f2584d9a7830f5.png]
 *  右为空(与上面同理）  
    a3 父节点和删除结点如果重合，直接让root指向删除结点的左边  
    a4父节点指向删除结点的左边

b.删除结点有两个孩子：  
替换法删除：通过**左子树的最大结点**或**右树的最小结点**来删除的结点替换，替换完就转化为a类的场景(**左子树为空**或**右子树为空**），删掉替换后的结点即可，并且此时的那个结点一定有固定的一边是空的，由你选择的是左子树的最大结点还是右子树的最小结点而定。

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

总代码：

template<class T>
    	struct BSTreeNode
    	{
        
    		BSTreeNode<T>* _left = nullptr;
    		BSTreeNode<T>* _right = nullptr;
    
    		T _key;
    
    		BSTreeNode(const T& key) :_key(key)
    		{
        }
    	};
    
    
    	template<class T>
    	class BStree
    	{
        
    		typedef BSTreeNode<T> Node;
    	private:
    		Node* _root = nullptr;
    		void _InOder(Node* root)
    		{
        
    			if (root == nullptr)
    			{
        
    				return;
    			}
    
    			_InOder(root->_left);
    			cout << root->_key << " ";
    			_InOder(root->_right);
    		}
    
    		
    		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* copyroot = nullptr;
    			copyroot = new Node(root->_key);
    
    			copyroot->_left=copy(root->_left);
    			copyroot->_right=copy(root->_right);
    
    			return copyroot;
    		}
    	public:
    		BStree()
    		{
        }
    		~BStree()
    		{
        
    			_Destroy(_root);
    		}
    		BStree(const BStree<T>& t)
    		{
        
    			_root = copy(t._root);
    			//在类里面可以看到私有的
    		}
    		BStree<T>& operator=(const BStree<T> t)
    		{
        
    			swap(_root, t._root);
    			return *this;
    		}
    
    		bool Insert(const T& key)
    		{
        
    			if (_root == nullptr)
    			{
        
    				_root = new Node(key);
    				return true;
    			}
    
    			Node* cur = _root;
    			Node* parent = _root;
    
    			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->_left = cur;
    			}
    			else if (parent->_key < key)
    			{
        
    				parent->_right = cur;
    			}
    
    			return true;
    		}
    
    		bool Find(const T& 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;
    		}
    
    
    		void InOder()
    		{
        
    			_InOder(_root);
    			cout << endl;
    		}
    
    
    		bool Erase(const T& key)
    		{
        
    			Node* cur = _root;
    			Node* parent = _root;
    
    			while (cur)
    			{
        
    
    				if (cur->_key < key)
    				{
        
    					parent = cur;
    					cur = cur->_right;
    				}
    				else if (cur->_key > key)
    				{
        
    					parent = cur;
    					cur = cur->_left;
    				}
    				//先寻找key的位置
    				else
    				{
        
    					//找到之后有两种情况：
    					//第一种就是托孤：不管有一个孩子还是没有孩子都可以处理
    					if (cur->_left == nullptr)
    					{
        
    						//这里的坑就是删除头结点位置，此时cur和parent在同一个位置
    						if (_root == cur)
    						{
        
    							_root = cur->_right;
    						}
    						else
    						{
        
    							if (parent->_left == cur)
    							{
        
    								parent->_left = cur->_right;
    							}
    							else
    							{
        
    								parent->_right = cur->_right;
    							}
    						}
    					}
    
    					else if (cur->_right == nullptr)
    					{
        
    						//同样是上面那个坑
    						if (_root == cur)
    						{
        
    							_root = cur->_left;
    						}
    						else
    						{
        
    							if (parent->_left == cur)
    							{
        
    								parent->_left = cur->_left;
    							}
    							else
    							{
        
    								parent->_right = cur->_left;
    							}
    						}
    					}
    					//第二种就是找到左树最大结点或右树最小结点，有两个孩子的时候
    					else
    					{
        
    						//左树的最大结点：
    						Node* _parent = cur;
    						Node* LeftMax = cur->_left;
    						while (LeftMax->_right)
    						{
        
    							_parent = LeftMax;
    							LeftMax = LeftMax->_right;
    						}
    						swap(LeftMax->_key, cur->_key);
    						if (_parent->_right == LeftMax)
    						{
        
    							_parent->_right = LeftMax->_left;
    						}
    
    						else
    						{
        
    							_parent->_left = LeftMax->_left;
    						}
    
    						cur = LeftMax;
    					}
    					delete cur;
    					return true;
    				}
    			}
    
    			return false;
    		}
    	};
    }

### 2.0版本（递归版本） ###

其实递归比循环好实现很多，只是存在栈溢出的问题罢了，并且递归有些地方是非常巧妙的，我们先来看看完整代码：

template<class T>
    	struct BSTreeNode
    	{
        
    		BSTreeNode<T>* _left = nullptr;
    		BSTreeNode<T>* _right = nullptr;
    
    		T _key;
    
    		BSTreeNode(const T& key) :_key(key)
    		{
        }
    	};
    
    
    	template<class T>
    	class BStree
    	{
        
    		typedef BSTreeNode<T> Node;
    	private:
    		Node* _root = nullptr;
    		void _InOder(Node* root)
    		{
        
    			if (root == nullptr)
    			{
        
    				return;
    			}
    
    			_InOder(root->_left);
    			cout << root->_key << " ";
    			_InOder(root->_right);
    		}
    
    		bool _InsertR(const T& key,Node*& root)
    		{
        
    			if (root == nullptr)
    			{
        
    				root = new Node (key);
    				return true;
    			}
    
    			if (root->_key > key)
    			{
        
    				return _InsertR(key, root->_left);
    			}
    			else if (root->_key < key)
    			{
        
    				return _InsertR(key, root->_right);
    			}
    			else
    			{
        
    				return false;
    			}
    		}
    
    		bool _FindR(const T& key, Node* root)
    		{
        
    			if (root == nullptr)
    			{
        
    				return false;
    			}
    			if (root->_key > key)
    			{
        
    				return _FindR(key, root->_left);
    			}
    			else if (root->_key < key)
    			{
        
    				return _FindR(key, root->_right);
    			}
    			else
    			{
        
    				return true;
    			}
    		}
    
    		bool _EraseR(const T& key, Node*& root)
    		{
        
    			if (root == nullptr)
    			{
        
    				return false;
    			}
    
    			if (root->_key > key)
    			{
        
    				return _EraseR(key, root->_left);
    			}
    			else if (root->_key < key)
    			{
        
    				return _EraseR(key, root->_right);
    			}
    			else
    			{
        
    				Node* del = root;
    				if (root->_right == nullptr)
    				{
        
    					root = root->_left;
    				}
    				else if (root->_left == nullptr)
    				{
        
    					root = root->_right;
    				}
    				else
    				{
        
    					
    					Node* LeftMax = root->_left;
    					while (LeftMax->_right)
    					{
        
    						LeftMax = LeftMax->_right;
    					}
    					swap(LeftMax->_key, root->_key);
    					_EraseR(key, root->_left);
    					del = LeftMax;
    				}
    				delete del;
    				return true;
    			}
    			
    		}
    
    		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* copyroot = nullptr;
    			copyroot = new Node(root->_key);
    
    			copyroot->_left=copy(root->_left);
    			copyroot->_right=copy(root->_right);
    
    			return copyroot;
    		}
    	public:
    		BStree()
    		{
        }
    		~BStree()
    		{
        
    			_Destroy(_root);
    		}
    		BStree(const BStree<T>& t)
    		{
        
    			_root = copy(t._root);
    			//在类里面可以看到私有的
    		}
    		BStree<T>& operator=(const BStree<T> t)
    		{
        
    			swap(_root, t._root);
    			return *this;
    		}
    
    		
    		bool InsertR(const T& key)
    		{
        
    			return _InsertR(key,_root);
    		}
    
    
    		bool FindR(const T& key)
    		{
        
    			return _FindR(key,_root);
    		}
    
    		void InOder()
    		{
        
    			_InOder(_root);
    			cout << endl;
    		}
    	
    		bool EraseR(const T& key)
    		{
        
    			return _EraseR(key, _root);
    		}
    	};
    }

我们来看一下递归在引用方面巧妙的使用：

这是循环的`Insert`：  
![在这里插入图片描述][a4e90ecd7bd44496a9d491eb7989afd5.png]  
这是递归的`_Insert`：  
![在这里插入图片描述][658c3790fbca4a4ead40a35f80f2e246.png]  
我们会明显发现递归在传参的时候传的是引用，为什么呢？接着往下看，循环的时候，为了使链接能够完成，我们会通过不断更新父节点来记录父节点，而递归的时候就不用。其实原因很显然，通过引用，在递归时的root就是他的父节点（上一个结点的`root->right`或`root->left`)的别名，此时已经具有链接关系，在这里直接赋值就可以了。  
![在这里插入图片描述][c6796459d3ed4690bb6beef802866eef.png]  
在这里就省去了很多麻烦的事情，这就是递归的巧妙之处，而我们的循环不能使用引用，因为引用不能改变指向，在循环里面用引用只会使指向混乱，而在递归里面，会建立很多栈帧，每一个栈帧使用一次引用，在不出错的情况下还减少了保存父节点的麻烦。

同样的erase也是，在递归的时候使用引用，不仅减少了parent保存的麻烦，还省去了父节点和删除结点重合情况的特殊处理。

递归版本：  
![递归版本][7c7cf7103bb049319d7c8c025bc4eb93.png]  
循环版本：  
![在这里插入图片描述][b99b0688a382435493efb422ac8d7a51.png]

## 三.搜索二叉树的应用： ##

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

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

1.  KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：  
    比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；  
    再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出  
    现次数就是<word, count>就构成一种键值对  
    还有就是我们平时刷身份证，平台通过我们身份证号码找到我们相关消息，只不过这个是更复杂的场景。下面我们来看一下具体的应用：

我们只需要把平常的多加一个value值即可，在插入的时候多插入一个值即可实现：

namespace key_value
    {
        
    	template<class T,class V>
    	struct BSTreeNode
    	{
        
    		BSTreeNode<T,V>* _left = nullptr;
    		BSTreeNode<T,V>* _right = nullptr;
    
    		T _key;
    		V _value;
    		BSTreeNode(const T& key,const V& value) :_key(key),_value(value)
    		{
        }
    	};
    
    
    	template<class T,class V>
    	class BStree
    	{
        
    		typedef BSTreeNode<T,V> Node;
    	private:
    		Node* _root = nullptr;
    		void _InOder(Node* root)
    		{
        
    			if (root == nullptr)
    			{
        
    				return;
    			}
    
    			_InOder(root->_left);
    			cout << root->_key << " "<<root->_value<<endl;
    
    			_InOder(root->_right);
    		}
    
    		void Destroy(Node*& root)
    		{
        
    			if (root == nullptr)
    			{
        
    				return;
    			}
    			Destroy(root->_left);
    			Destroy(root->_right);
    			delete root;
    			root = nullptr;
    		}
    	public:
    		BStree()
    		{
        }
    		~BStree()
    		{
        
    			Destroy(_root);
    		}
    		bool Insert(const T& key,const V& value)
    		{
        
    			if (_root == nullptr)
    			{
        
    				_root = new Node(key,value);
    				return true;
    			}
    
    			Node* cur = _root;
    			Node* parent = _root;
    
    			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,value);
    			if (parent->_key > key)
    			{
        
    				parent->_left = cur;
    			}
    			else if (parent->_key < key)
    			{
        
    				parent->_right = cur;
    			}
    
    			return true;
    		}
    
    
    		Node* Find(const T& 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;
    		}
    
    		void InOder()
    		{
        
    			_InOder(_root);
    			cout << endl;
    		}
    
    
    		bool Erase(const T& key)
    		{
        
    			Node* cur = _root;
    			Node* parent = _root;
    
    			while (cur)
    			{
        
    
    				if (cur->_key < key)
    				{
        
    					parent = cur;
    					cur = cur->_right;
    				}
    				else if (cur->_key > key)
    				{
        
    					parent = cur;
    					cur = cur->_left;
    				}
    				//先寻找key的位置
    				else
    				{
        
    					//找到之后有两种情况：
    					//第一种就是托孤：不管有一个孩子还是没有孩子都可以处理
    					if (cur->_left == nullptr)
    					{
        
    						//这里的坑就是删除头结点位置，此时cur和parent在同一个位置
    						if (_root == cur)
    						{
        
    							_root = cur->_right;
    						}
    						else
    						{
        
    							if (parent->_left == cur)
    							{
        
    								parent->_left = cur->_right;
    							}
    							else
    							{
        
    								parent->_right = cur->_right;
    							}
    						}
    					}
    
    					else if (cur->_right == nullptr)
    					{
        
    						//同样是上面那个坑
    						if (_root == cur)
    						{
        
    							_root = cur->_left;
    						}
    						else
    						{
        
    							if (parent->_left == cur)
    							{
        
    								parent->_left = cur->_left;
    							}
    							else
    							{
        
    								parent->_right = cur->_left;
    							}
    						}
    					}
    					//第二种就是找到左树最大结点或右树最小结点，有两个孩子的时候
    					else
    					{
        
    						//左树的最大结点：
    						Node* _parent = cur;
    						Node* LeftMax = cur->_left;
    						while (LeftMax->_right)
    						{
        
    							_parent = LeftMax;
    							LeftMax = LeftMax->_right;
    						}
    						swap(LeftMax->_key, cur->_key);
    						if (_parent->_right == LeftMax)
    						{
        
    							_parent->_right = LeftMax->_left;
    						}
    
    						else
    						{
        
    							_parent->_left = LeftMax->_left;
    						}
    
    						cur = LeftMax;
    					}
    					delete cur;
    					return true;
    				}
    			}
    
    			return false;
    		}
    
    	};
    }

字典的例子：

void TestBSTree3()
    {
        
    	//BSTree<string, Date> carTree;
    
    	key_value::BStree<string, string> dict;
    	dict.Insert("insert", "插入");
    	dict.Insert("sort", "排序");
    	dict.Insert("right", "右边");
    	dict.Insert("date", "日期");
    
    	string str;
    	while (cin >> str)
    	{
        
    		key_value::BSTreeNode<string, string>* ret = dict.Find(str);
    		if (ret)
    		{
        
    			cout << ret->_value << endl;
    		}
    		else
    		{
        
    			cout << "无此单词" << endl;
    		}
    	}
    }

统计个数的例子：

void TestBSTree4()
    {
        
    	// 11:44继续
    	// 统计水果出现的次数
    	string arr[] = {
         "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
    
    	key_value::BStree<string, int> st;
    	for (auto & str : arr)
    	{
        
    		auto ret = st.Find(str);
    		if (ret)
    		{
        
    			ret->_value++;
    		}
    		else
    		{
        
    			st.Insert(str,1);
    		}
    	}
    
    	st.InOder();
    }

## 总结 ##

其实搜索二叉树就是将前面的数据结构和我们所学的C++进行了结合！其实我们不难看出，对于循环和递归，循环的使用就会伴随着很多特殊情况的出现，我们都要一一解决，并且不好读懂，但是他的性能很高，而递归则是很简短并且容易看懂，但是代价就是会出现栈溢出的现象。今后要根据实际情况具体选择。

更新不易，辛苦各位小伙伴们动动小手，👍三连走一走💕💕 ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

> **专栏订阅：**  
> [每日一题][Link 2]  
> [C语言学习][C 1]  
> [算法][Link 3]  
> [智力题][Link 4]  
> [初阶数据结构][Link 5]  
> [Linux学习][Linux]  
> [C++学习][C]  
> 更新不易，辛苦各位小伙伴们动动小手，👍三连走一走💕💕 ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

![在这里插入图片描述][55270e2552774a17a711aa978da84193.gif_pic_center]

[6ac7346dc5944908b5dd227e55fab217.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/af6f82d637fd4712a4395d94ce18c682.gif
[C]: https://blog.csdn.net/qq_74310471/category_12289978.html
[Link 1]: https://blog.csdn.net/qq_74310471?spm=1000.2115.3001.5343
[VS2022_C]: https://gitee.com/zhangxuruihhhh/c-language-learning
[85d8f838a7524c8bb8bed80b7ac059c1.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7a81c03474f640e9b2c40c1cf33cf7f5.gif
[56d2c5a7dec74d2780df290907024765.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d46da1595cb14731ba327d081513c9a5.png
[78dfb7c980c64eed9c29ffcb0bd7e270.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/9e6f919fed794cbbaa741fce82b68c22.png
[4a24462983874a0881f2584d9a7830f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3a700a95bea34016bd9a4b0b9c37bb77.png
[2bb88ea41e494935902ee2feb8432d9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a51986c45b28464d9ed8282184d0f39b.png
[a4e90ecd7bd44496a9d491eb7989afd5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/b8271a64f3544925b49dc19da92ca120.png
[658c3790fbca4a4ead40a35f80f2e246.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/6ee7b5a2a5db4629b779a759e6792ad0.png
[c6796459d3ed4690bb6beef802866eef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8488c1927b5145edb10eececdebabe36.png
[7c7cf7103bb049319d7c8c025bc4eb93.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d10d3e2aa1bd4838a6f9972fd726693c.png
[b99b0688a382435493efb422ac8d7a51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7d5dbf8f566d4cec908d98ce2ed4dab5.png
[Link 2]: https://blog.csdn.net/qq_74310471/category_12166401.html?spm=1001.2014.3001.5482
[C 1]: https://blog.csdn.net/qq_74310471/category_12157207.html?spm=1001.2014.3001.5482
[Link 3]: https://blog.csdn.net/qq_74310471/category_12144452.html?spm=1001.2014.3001.5482
[Link 4]: https://blog.csdn.net/qq_74310471/category_12166402.html
[Link 5]: https://blog.csdn.net/qq_74310471/category_12216969.html?spm=1001.2014.3001.5482
[Linux]: https://blog.csdn.net/qq_74310471/category_12291120.html
[55270e2552774a17a711aa978da84193.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/83268d791bd84635b926c7146d178824.gif