• C++——二叉搜索树

    目录

    二叉搜索树

    二叉搜索树实现 

    非递归插入|非递归查找

    删除 

    推导阶段 

    非递归删除代码 

    递归查找 

     递归插入

    递归删除 

    析构函数 

    拷贝构造 

    赋值重载

    完整代码 

     二叉搜索树的应用

    Key/Value模型 

     

    二叉搜索树

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

    二叉搜索树实现 

    非递归插入|非递归查找

    1. #include
    2. using namespace std;
    3. template<class K>
    4. class BStreeNode
    5. {
    6. public:
    7. 	BStreeNode(const K& key)
    8. 		:_left(nullptr),
    9. 		_right(nullptr),
    10. 		_key(key)
    11. 	{}
    12. 	BStreeNode* _left;
    13. 	BStreeNode* _right;
    14. 	K _key;
    15. };
    16. template<class K>
    17. class BStree
    18. {
    19. 	typedef BStreeNode Node;
    20. public:
    21. 	bool Insert(const K& key)
    22. 	{
    23. 		if (_root == nullptr)
    24. 		{
    25. 			_root = new Node(key);
    26. 			return true;
    27. 		}
    28.  
    29. 		Node* parent = nullptr;
    30. 		Node* cur = _root;
    31. 		while (cur)
    32. 		{
    33. 			if (cur->_key < key)
    34. 			{
    35. 				parent = cur;
    36. 				cur = cur->_right;
    37. 			}
    38. 			else if (cur->_key > key)
    39. 			{
    40. 				parent = cur;
    41. 				cur = cur->_left;
    42. 			}
    43. 			else
    44. 			{
    45. 				return false;
    46. 			}
    47. 		}
    48.  
    49. 		cur = new Node(key);
    50. 		if (parent->_key < key)
    51. 		{
    52. 			parent->_right = cur;
    53. 		}
    54. 		else
    55. 		{
    56. 			parent->_left = cur;
    57. 		}
    58.  
    59. 		return true;
    60. 	}
    61. bool Find(const K& key)//查找
    62. 	{
    63. 		Node* cur = _root;
    64. 		while (cur)
    65. 		{
    66. 			if (cur->_key < key)
    67. 			{
    68. 				cur = cur->_right;
    69. 			}
    70. 			else if (cur->_key > key)
    71. 			{
    72. 				cur = cur->_left;
    73. 			}
    74. 			else
    75. 			{
    76. 				return true;
    77. 			}
    78. 		}
    79.  
    80. 		return true;
    81. 	}
    82. 	void InOrder()
    83. 	{
    84. 		_InOrder(_root);
    85. 	}
    86. private:
    87. 	void _InOrder(Node *root)
    88. 	{
    89. 		if (root == nullptr)
    90. 			return;
    91. 		_InOrder(root->_left);
    92. 		cout << root->_key << " ";
    93. 		_InOrder(root->_right);
    94. 	}
    95. private:
    96. 	Node* _root = nullptr;
    97. };
    98. int main()
    99. {
    100. 	BStree<int> t;
    101. 	int a[] = { 1,1,2,2,3,6,165,132,4185,123 };
    102. 	for (auto e : a)
    103. 	{
    104. 		t.Insert(e);
    105. 	}
    106. 	t.InOrder();
    107. 	return 0;
    108. }

     

    可去重 

    删除 

    推导阶段 

     1.若要删除的节点是叶子节点，直接删除即可

    2.删除节点只有一个孩子

    若左为空，则让父亲节点指向该节点的右子树以删除3为例

    若果要删除跟节点，而且左为空，若要删除8，我们更新根节点即可，让根节点指向10

    若右为空，则让父亲指向左子树，以删除14为例

      若果要删除跟节点，而且右为空，若要删除8，让根节点指向3即可

     3.要删除的节点其左右节点都不为空

    我们可以采用替换法删除节点

    用左子树的最大节1点或右子树的最小节点4，若采用右树的最小节点，交换3和4删除4之后，删除3，但还有一个子节点5，我们让5成为6的左节点

    若要删除8，这里采用右树最左节点的替换法，右树的最左节点就是10自己，如果这样写会有错误，while循环都不会进去，minparent就是空，而后面minParent->_left = min->_right;这个语句会出错，修正方法，让minparent一开始就是cur，并且加个判断。

    这样写即可

    非递归删除代码 

    1. 	bool Erase(const K& key)//删除
    2. 	{
    3. 		//若有一个子节点，删除父节点后，让子节点填充
    4. 		//若有俩个子节点，父节点删除后
    5. 		//1.用左子树的最大节点替换父节点
    6. 		//2.或右子树的最小节点替换父节点
    7. 		Node* parent = nullptr;
    8. 		Node* cur = _root;
    9. 		while (cur)
    10. 		{
    11. 			if (cur->_key > key)
    12. 			{
    13. 				parent = cur;
    14. 				cur = cur->_left;
    15. 			}
    16. 			else if (cur->_key < key)
    17. 			{
    18. 				parent = cur;
    19. 				cur = cur->_right;
    20. 			}
    21. 			else//找到了
    22. 			{
    23. 				if (cur->_left == nullptr)//如果要删除的节点左为空
    24. 				{
    25. 					if (cur == _root)//如果要删除的是根节点(这种情况根节点只有右子树，因为左为空)
    26. 					{
    27. 						_root = cur->_right;
    28. 					}
    29. 					else
    30. 					{
    31. 						if (cur == parent->_left)//判断要删除的节点是父亲的左节点还是右节点
    32. 						{
    33. 							parent->_left = cur->_right;
    34. 						}
    35. 						else
    36. 						{
    37. 							parent->_right = cur->_right;
    38. 						}
    39. 					}
    40. 					delete cur;
    41. 					cur = nullptr;
    42. 				}
    43. 				else if (cur->_right == nullptr)//如果要删除的节点右为空
    44. 				{
    45. 					if (cur == _root)
    46. 					{
    47. 						_root = cur->_left;
    48. 					}
    49. 					else
    50. 					{
    51. 						if (cur == parent->_left)//判断要删除的节点是父亲的左节点还是右节点
    52. 						{
    53. 							parent->_left = cur->_left;
    54. 						}
    55. 						else
    56. 						{
    57. 							parent->_right = cur->_left;
    58. 						}
    59. 					}
    60. 					delete cur;
    61. 					cur = nullptr;
    62. 				}
    63. 				else//左右都为空，叶子节点,这里采用用右树的最小节点进行删除
    64. 				{
    65. 					Node* minParent = cur;
    66. 					Node*min = cur->_right;//cur是要删除的节点
    67. 					while (min->_left)//寻找最小节点
    68. 					{
    69. 						minParent = min;
    70. 						min = min->_left;
    71. 					}
    72. 					swap(cur->_key, min->_key);
    73. 					if (minParent->_left == min)
    74. 					{
    75. 						minParent->_left = min->_right;
    76. 					}
    77. 					else
    78. 					minParent->_right = min->_right;
    79. 					delete min;
    80. 				}
    81. 				return true;
    82. 			}
    83. 		}
    84. 		return false;
    85. 	}

    递归查找 

    1. 	bool _FindR(Node *root,const K& key)
    2. 	{
    3. 		if (root == nullptr)
    4. 			return false;
    5. 		if (root->_key < key)
    6. 		{
    7. 			return _FindR(root->right, key);
    8. 		}
    9. 		else if (root->_key > key)
    10. 		{
    11. 			return _FindR(root->left, key);
    12. 		}
    13. 		else
    14. 		{
    15. 			return true;
    16. 		}
    17. 	}

     递归插入

    这种插入写法会导致二叉树断开

     这里的Node没有跟父节点连接上，而是创建了一个空间单独在那里

     加上引用即可

    1. 	bool _InsertR(Node*& root, const K& key)
    2. 	{
    3. 		if (root == nullptr)//根为空，直接插入
    4. 		{
    5. 			root = new Node(key);
    6. 			return true;
    7. 		}
    8. 		if (root->_key < key)
    9. 		{
    10. 			return _InsertR(root->_right, key);
    11. 		}
    12. 		else if (root->_key > key)
    13. 		{
    14. 			return _InsertR(root->_left, key);
    15. 		}
    16. 		else
    17. 		{
    18. 			return false;
    19. 		}
    20. 	}

    递归删除 

    1. 	bool _Eraser(Node*& root, const K& key)
    2. 	{
    3. 		if (root == nullptr)
    4. 			return false;
    5. 		if (root->_key < key)
    6. 		{
    7. 			return _Eraser(root->_right, key);
    8. 		}
    9. 		else if (root->_key > key)
    10. 		{
    11. 			return _Eraser(root->_left, key);
    12. 		}
    13. 		else
    14. 		{
    15. 			Node* del = root;
    16. 			if (root->_left == nullptr)
    17. 			{
    18. 				root = root->_right;
    19. 			}
    20. 			else if (root->_right == nullptr)
    21. 			{
    22. 				root = root->_left;//由于是引用，可直接这样将二叉树连接起来
    23. 			}
    24. 			else
    25. 			{
    26. 				//找右树的最左节点
    27. 				Node* min = root->_right;
    28. 				while (min->_left)
    29. 				{
    30. 					min = min->_left;
    31. 				}
    32. 				swap(root->_key, min->_key);
    33. 				return _Eraser(root->_right, key);
    34. 			}
    35. 			delete del;
    36. 			return true;
    37. 		}
    38. 	}

    析构函数 

    1. 	~BStree()
    2. 	{
    3. Destory(_root);
    4. 	}
    5. private:
    6. 	void Destory(Node*& root)//采用引用可让root置空起作用
    7. 	{
    8. 		if (root ==nullptr)
    9. 			return;
    10. 		Destory(root->_left);
    11. 		Destory(root->right);
    12. 		delete root;
    13. 		root=nullptr
    14. 	}

    拷贝构造 

     注：拷贝构造也是构造，如果写了构造，编译器不会生成默认构造，会报错没有合适的默认构造

    1. 	BStree(const BStree & t)
    2. 	{
    3. 		_root = _Copy(t._root);
    4. 	}
    5. Node* _Copy(Node* root)
    6. 	{
    7. 		if (root == nullptr)
    8. 		{
    9. 			return nullptr;
    10. 		}
    11. 		Node* copyRoot = new Node(root->_key);
    12. 		copyRoot->_left = _Copy(root->_left);
    13. 		copyRoot->_right = _Copy(root->_right);
    14. 		return copyRoot;
    15. 	}

    我们需加默认构造 

    默认构造也可写为BSTree()=default;

    这是强制编译器生成默认构造，是C++11的用法

    赋值重载

    1. 	BStree& operator=(BStree t)
    2. 	{
    3. 		swap(_root, t._root);
    4. 		return *this;
    5. 	}

    搜索二叉树增删查的时间复杂度是：O（h），h代表高度 

    完整代码 

    1. #include
    2. using namespace std;
    3. template<class K>
    4. class BStreeNode
    5. {
    6. public:
    7. 	BStreeNode(const K& key)
    8. 		:_left(nullptr),
    9. 		_right(nullptr),
    10. 		_key(key)
    11. 	{}
    12. 	BStreeNode* _left;
    13. 	BStreeNode* _right;
    14. 	K _key;
    15. };
    16. template<class K>
    17. class BStree
    18. {
    19. 	typedef BStreeNode Node;
    20. public:
    21. 	bool Insert(const K& key)
    22. 	{
    23. 		if (_root == nullptr)
    24. 		{
    25. 			_root = new Node(key);
    26. 			return true;
    27. 		}
    28.  
    29. 		Node* parent = nullptr;
    30. 		Node* cur = _root;
    31. 		while (cur)
    32. 		{
    33. 			if (cur->_key < key)
    34. 			{
    35. 				parent = cur;
    36. 				cur = cur->_right;
    37. 			}
    38. 			else if (cur->_key > key)
    39. 			{
    40. 				parent = cur;
    41. 				cur = cur->_left;
    42. 			}
    43. 			else
    44. 			{
    45. 				return false;
    46. 			}
    47. 		}
    48.  
    49. 		cur = new Node(key);
    50. 		if (parent->_key < key)
    51. 		{
    52. 			parent->_right = cur;
    53. 		}
    54. 		else
    55. 		{
    56. 			parent->_left = cur;
    57. 		}
    58.  
    59. 		return true;
    60. 	}
    61. 	void InOrder()//排序
    62. 	{
    63. 		_InOrder(_root);
    64. 	}
    65. 	bool Find(const K& key)//查找
    66. 	{
    67. 		Node* cur = _root;
    68. 		while (cur)
    69. 		{
    70. 			if (cur->_key < key)
    71. 			{
    72. 				cur = cur->_right;
    73. 			}
    74. 			else if (cur->_key > key)
    75. 			{
    76. 				cur = cur->_left;
    77. 			}
    78. 			else
    79. 			{
    80. 				return true;
    81. 			}
    82. 		}
    83.  
    84. 		return true;
    85. 	}
    86. 	bool Erase(const K& key)//删除
    87. 	{
    88. 		//若有一个子节点，删除父节点后，让子节点填充
    89. 		//若有俩个子节点，父节点删除后
    90. 		//1.用左子树的最大节点替换父节点
    91. 		//2.或右子树的最小节点替换父节点
    92. 		Node* parent = nullptr;
    93. 		Node* cur = _root;
    94.  
    95. 		while (cur)
    96. 		{
    97. 			if (cur->_key > key)
    98. 			{
    99. 				parent = cur;
    100. 				cur = cur->_left;
    101. 			}
    102. 			else if (cur->_key < key)
    103. 			{
    104. 				parent = cur;
    105. 				cur = cur->_right;
    106. 			}
    107. 			else//找到了
    108. 			{
    109. 				if (cur->_left == nullptr)//如果要删除的节点左为空
    110. 				{
    111. 					if (cur == _root)//如果要删除的是根节点(这种情况根节点只有右子树，因为左为空)
    112. 					{
    113. 						_root = cur->_right;
    114. 					}
    115. 					else
    116. 					{
    117. 						if (cur == parent->_left)//判断要删除的节点是父亲的左节点还是右节点
    118. 						{
    119. 							parent->_left = cur->_right;
    120. 						}
    121. 						else
    122. 						{
    123. 							parent->_right = cur->_right;
    124. 						}
    125. 					}
    126. 					delete cur;
    127. 					cur = nullptr;
    128. 				}
    129. 				else if (cur->_right == nullptr)//如果要删除的节点右为空
    130. 				{
    131. 					if (cur == _root)
    132. 					{
    133. 						_root = cur->_left;
    134. 					}
    135. 					else
    136. 					{
    137. 						if (cur == parent->_left)//判断要删除的节点是父亲的左节点还是右节点
    138. 						{
    139. 							parent->_left = cur->_left;
    140. 						}
    141. 						else
    142. 						{
    143. 							parent->_right = cur->_left;
    144. 						}
    145. 					}
    146. 					delete cur;
    147. 					cur = nullptr;
    148. 				}
    149. 				else//左右都为空，叶子节点,这里采用用右树的最小节点进行删除
    150. 				{
    151. 					Node* minParent = cur;
    152. 					Node* min = cur->_right;//cur是要删除的节点
    153. 					while (min->_left)//寻找最小节点
    154. 					{
    155. 						minParent = min;
    156. 						min = min->_left;
    157. 					}
    158. 					swap(cur->_key, min->_key);
    159. 					if (minParent->_left == min)
    160. 					{
    161. 						minParent->_left = min->_right;
    162. 					}
    163. 					else
    164. 						minParent->_right = min->_right;
    165. 					delete min;
    166. 				}
    167. 				return true;
    168. 			}
    169. 		}
    170. 		return false;
    171. 	}
    172. 	bool FindR(const K& key)
    173. 	{
    174. 		return _FindR(_root, key);
    175. 	}
    176. 	bool InsertR(const K& key)
    177. 	{
    178. 		return _InsertR(_root, key);
    179. 	}
    180. 	bool EraseR(const K& key)
    181. 	{
    182. 		return _Eraser(_root, key);
    183. 	}
    184. 	~BStree()
    185. 	{
    186. 		Destory(_root);
    187. 	}
    188. 	BStree()
    189. 	{}
    190. 	BStree(const BStree& t)
    191. 	{
    192. 		_root = _Copy(t._root);
    193. 	}
    194. 	BStree& operator=(BStree t)
    195. 	{
    196. 		swap(_root, t._root);
    197. 		return *this;
    198. 	}
    199. private:
    200. 	Node* _Copy(Node* root)
    201. 	{
    202. 		if (root == nullptr)
    203. 		{
    204. 			return nullptr;
    205. 		}
    206. 		Node* copyRoot = new Node(root->_key);
    207. 		copyRoot->_left = _Copy(root->_left);
    208. 		copyRoot->_right = _Copy(root->_right);
    209. 		return copyRoot;
    210. 	}
    211. 	void Destory(Node*& root)//采用引用可让root置空起作用
    212. 	{
    213. 		if (root == nullptr)
    214. 			return;
    215. 		Destory(root->_left);
    216. 		Destory(root->_right);
    217. 		delete root;
    218. 		root = nullptr;
    219. 	}
    220. 	bool _Eraser(Node*& root, const K& key)
    221. 	{
    222. 		if (root == nullptr)
    223. 			return false;
    224. 		if (root->_key < key)
    225. 		{
    226. 			return _Eraser(root->_right, key);
    227. 		}
    228. 		else if (root->_key > key)
    229. 		{
    230. 			return _Eraser(root->_left, key);
    231. 		}
    232. 		else
    233. 		{
    234. 			Node* del = root;
    235. 			if (root->_left == nullptr)
    236. 			{
    237. 				root = root->_right;
    238. 			}
    239. 			else if (root->_right == nullptr)
    240. 			{
    241. 				root = root->_left;//由于是引用，可直接这样将二叉树连接起来
    242. 			}
    243. 			else
    244. 			{
    245. 				//找右树的最左节点
    246. 				Node* min = root->_right;
    247. 				while (min->_left)
    248. 				{
    249. 					min = min->_left;
    250. 				}
    251. 				swap(root->_key, min->_key);
    252. 				return _Eraser(root->_right, key);
    253. 			}
    254. 			delete del;
    255. 			return true;
    256. 		}
    257. 	}
    258. 	bool _InsertR(Node*& root, const K& key)
    259. 	{
    260. 		if (root == nullptr)//根为空，直接插入
    261. 		{
    262. 			root = new Node(key);
    263. 			return true;
    264. 		}
    265. 		if (root->_key < key)
    266. 		{
    267. 			return _InsertR(root->_right, key);
    268. 		}
    269. 		else if (root->_key > key)
    270. 		{
    271. 			return _InsertR(root->_left, key);
    272. 		}
    273. 		else
    274. 		{
    275. 			return false;
    276. 		}
    277. 	}
    278. 	bool _FindR(Node *root,const K& key)
    279. 	{
    280. 		if (root == nullptr)
    281. 			return false;
    282. 		if (root->_key < key)
    283. 		{
    284. 			return _FindR(root->right, key);
    285. 		}
    286. 		else if (root->_key > key)
    287. 		{
    288. 			return _FindR(root->left, key);
    289. 		}
    290. 		else
    291. 		{
    292. 			return true;
    293. 		}
    294. 	}
    295. 	void _InOrder(Node *root)
    296. 	{
    297. 		if (root == nullptr)
    298. 			return;
    299. 		_InOrder(root->_left);
    300. 		cout << root->_key << " ";
    301. 		_InOrder(root->_right);
    302. 	}
    303. private:
    304. 	Node* _root = nullptr;
    305. };
    306. int main()
    307. {
    308. 	BStree<int> t;
    309. 	int a[] = { 1,1,2,2,3,6,165,132,4185,123 };
    310. 	for (auto e : a)
    311. 	{
    312. 		t.Insert(e);
    313. 	}
    314. 	BStree<int> copy = t;
    315. 	copy.InOrder();
    316. 	t.InOrder();
    317. 	BStree<int> t1;
    318. 	t1.Insert(2);
    319. 	t1.Insert(1);
    320. 	t1.Insert(3);
    321. 	copy = t1;
    322. 	copy.InOrder();
    323. 	cout << endl;
    324. 	t1.InOrder();
    325. 	cout << endl;
    326. 	return 0;
    327. }

     二叉搜索树的应用

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

    在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误

    KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方
    式在现实生活中非常常见：
    比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
    文单词与其对应的中文就构成一种键值对；


    再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
    现次数就是就构成一种键值对
    KV模型通过K去找V

    Key/Value模型 

    1. namespace KeyValue
    2. {
    3. 	template<class K, class V>
    4. 	struct BSTreeNode
    5. 	{
    6. 		BSTreeNode* _left;//Key和Value绑到一起
    7. 		BSTreeNode* _right;
    8. 		K _key;
    9. 		V _value;
    10.  
    11. 		BSTreeNode(const K& key, const V& value)
    12. 			:_left(nullptr)
    13. 			, _right(nullptr)
    14. 			, _key(key)
    15. 			, _value(value)
    16. 		{}
    17. 	};
    18.  
    19. 	template<class K, class V>
    20. 	class BSTree
    21. 	{
    22. 		typedef BSTreeNode Node;
    23. 	public:
    24. 		bool Insert(const K& key, const V& value)
    25. 		{
    26. 			if (_root == nullptr)
    27. 			{
    28. 				_root = new Node(key, value);
    29. 				return true;
    30. 			}
    31.  
    32. 			Node* parent = nullptr;
    33. 			Node* cur = _root;
    34. 			while (cur)
    35. 			{
    36. 				if (cur->_key < key)
    37. 				{
    38. 					parent = cur;
    39. 					cur = cur->_right;
    40. 				}
    41. 				else if (cur->_key > key)
    42. 				{
    43. 					parent = cur;
    44. 					cur = cur->_left;
    45. 				}
    46. 				else
    47. 				{
    48. 					return false;
    49. 				}
    50. 			}
    51.  
    52. 			cur = new Node(key, value);
    53. 			if (parent->_key < key)
    54. 			{
    55. 				parent->_right = cur;
    56. 			}
    57. 			else
    58. 			{
    59. 				parent->_left = cur;
    60. 			}
    61.  
    62. 			return true;
    63. 		}
    64.  
    65. 		Node* Find(const K& key)//查找的时候以K去查找，返回的时候返回节点指针，以便于修改
    66. 		{
    67. 			Node* cur = _root;
    68. 			while (cur)
    69. 			{
    70. 				if (cur->_key < key)
    71. 				{
    72. 					cur = cur->_right;
    73. 				}
    74. 				else if (cur->_key > key)
    75. 				{
    76. 					cur = cur->_left;
    77. 				}
    78. 				else
    79. 				{
    80. 					return cur;
    81. 				}
    82. 			}
    83.  
    84. 			return nullptr;
    85. 		}
    86.  
    87. 		bool Erase(const K& key)//用K删除
    88. 		{
    89. 			//...
    90.  
    91. 			return true;
    92. 		}
    93.  
    94. 		void InOrder()
    95. 		{
    96. 			_InOrder(_root);
    97. 			cout << endl;
    98. 		}
    99. 	private:
    100.  
    101. 		void _InOrder(Node* root)
    102. 		{
    103. 			if (root == nullptr)
    104. 			{
    105. 				return;
    106. 			}
    107.  
    108. 			_InOrder(root->_left);
    109. 			cout << root->_key << ":" << root->_value << endl;
    110. 			_InOrder(root->_right);
    111. 		}
    112. 	private:
    113. 		Node* _root = nullptr;
    114. 	};

    英译汉

     统计水果出现的次数

     链表相交和复杂链表的赋值可用kv模型。

  • 相关阅读:
    双周赛114（模拟、枚举 + 哈希、DFS）
    洛谷 P3966 [TJOI2013]单词（AC自动机， fail 树）
    数字化工厂系统有什么现实优势
    Aws EKS 技术文章
    如何减少爬虫产生的网络负载：爬取间隔和缓存控制策略
    【算法集训 | 暑期刷题营】7.28题---01背包问题
    分库分表实战：竿头日上—千万级数据优化之读写分离
    教你如何使用API接口获取数据！
    一种能够使身体吸收火气、水气和风气的电脑
    A类电能质量在线监测装置
  • 原文地址：https://blog.csdn.net/weixin_49449676/article/details/127480046