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

    前言

    作者：小蜗牛向前冲

    名言：我可以接受失败，但我不能接受放弃

     如果觉的博主的文章还不错的话，还请点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正。

    目录

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

    1、什么是二叉搜索树

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

    二、底层模拟实现

    1、构建二叉搜索树

    2、二叉搜索树的查找

    3、二叉搜索树的插入

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

     5、完整代码实现

    三、二叉搜索树的应用

    1、K模型

    2、KV模型

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

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

    1、什么是二叉搜索树

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

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

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

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

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

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

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

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

    •  最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：O(log n)
    • 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为O(n)

    二、底层模拟实现

    1、构建二叉搜索树

    1.  
    2. 	template<class K>
    3. 	struct BSTreeNode
    4. 	{
    5. 		BSTreeNode* _left;
    6. 		BSTreeNode* _right;
    7. 		K _key;
    8.  
    9. 		BSTreeNode(const K& key)
    10. 			:_key(key)
    11. 			, _left(nullptr)
    12. 			, _right(nullptr)
    13. 		{}
    14. 	};
    15.  
    16. 	template<class K>
    17. 	class BSTree
    18. 	{
    19. 		typedef BSTreeNode Node;
    20. 	public://函数
    21. 	private:
    22.          Node* _root = nullptr;
    23.     }

    这里我们定义好节点，和树的主体就好了，下面我的二叉搜索树的功能函数多在类中实现。

    2、二叉搜索树的查找

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

    查找原则：

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

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

    普通写法：

    1. //查找
    2. bool Find(const K& key)
    3. {
    4. 	Node* cur = _root;
    5. 	while (cur)
    6. 	{
    7. 		if (cur->_key > key)
    8. 		{
    9. 			cur = cur->_left;
    10. 		}
    11. 		else if (cur->_key < key)
    12. 		{
    13. 			cur = cur->_right;
    14. 		}
    15. 		else
    16. 		{
    17. 			return true;
    18. 		}
    19. 	}
    20. 	return false;
    21. }

    递归写法：

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

    这二种写法，在这里好像看不出来特别大的差别。

    3、二叉搜索树的插入

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

    我们要找到插入的位置。然后在new一个节点进连接就可以

    插入的具体过程如下：

    a. 树为空，则直接新增节点，赋值给root指针

    b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

    普通写法： 

    1. 	bool Inert(const K& key)
    2. 	{
    3. 		if (_root == nullptr)
    4. 		{
    5. 			_root = new Node(key);
    6. 			return true;
    7. 		}
    8.  
    9. 		Node* parent = nullptr;
    10. 		Node* cur = _root;
    11. 		//遍历树，找插入位置
    12. 		while (cur)
    13. 		{
    14. 			if (cur->_key > key)
    15. 			{
    16. 				parent = cur;
    17. 				cur = cur->_left;
    18. 			}
    19. 			else if (cur->_key < key)
    20. 			{
    21. 				parent = cur;
    22. 				cur = cur->_right;
    23. 			}
    24. 			else
    25. 			{
    26. 				return false;
    27. 			}
    28. 		}
    29. 		//创建节点
    30. 		cur = new Node(key);
    31.  
    32. 		//连接树
    33. 		if (parent->_key > key)
    34. 		{
    35. 			parent->_left = cur;
    36. 		}
    37. 		else
    38. 		{
    39. 			parent->_right = cur;
    40. 		}
    41. 		return true;
    42. 	}

    递归写法：

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

    递归写法最让我们感到绝妙的是我们在这里传root用的是引用，因为用递归时(如果没有用root的引用)并没有传父亲节点，这也就在连接的时候会遇到到问题，但是我们这里传了root的引用就可以解决这个问题

    这里当我们要插入9，到我们递归到root == 10时候,在进行递归时，会往root->left递归，指向空,就可以插入，而&root是root->left指针的别名，就可以完美的连接起来。

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

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

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

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

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

    • 情况1：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除
    • 情况2：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除
    • 情况3：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点 中，再来处理该结点的删除问题--替换法删除

    普通写法：

    这里我们重点注意第三种情况，这里我们是找左树的最大或者说是右树的最小和我们要删除的数，进行替换在删除就可以了。

    1. //删除
    2. bool Erase(const K& key)
    3. {
    4. 	Node* parent = nullptr;
    5. 	Node* cur = _root;
    6. 	while (cur)
    7. 	{
    8. 		//先找到要删除的数
    9. 		if (cur->_key > key)
    10. 		{
    11. 			parent = cur;
    12. 			cur = cur->_left;
    13. 		}
    14. 		else if (cur->_key < key)
    15. 		{
    16. 			parent = cur;
    17. 			cur = cur->_right;
    18. 		}
    19. 		else
    20. 		{
    21. 			//1、左为空
    22. 			//2、右为空
    23. 			// 1.2都可以直接删除
    24. 			//在直接删除前，我们还要做好cur的左右节点的链接工作，并处理特殊情况(cur==_root)
    25. 			if (cur->_left == nullptr)
    26. 			{
    27. 				//处理特殊情况
    28. 				if (cur == _root)
    29. 				{
    30. 					_root = cur->_right;
    31. 				}
    32. 				else
    33. 				{
    34. 					if (parent->_left == cur)
    35. 					{
    36. 						parent->_left = cur->_right;
    37. 					}
    38. 					else
    39. 					{
    40. 						parent->_right = cur->_right;
    41. 					}
    42. 				}
    43. 				delete cur;
    44. 			}
    45. 			else if (cur->_right == nullptr)
    46. 			{
    47. 				//处理特殊情况
    48. 				if (cur == _root)
    49. 				{
    50. 					_root = cur->_left;
    51. 				}
    52. 				else
    53. 				{
    54. 					if (parent->_left == cur)
    55. 					{
    56. 						parent->_left = cur->_left;
    57. 					}
    58. 					else
    59. 					{
    60. 						parent->_right = cur->_left;
    61. 					}
    62. 				}
    63. 				delete cur;
    64. 			}

    递归写法：

    1. bool _EraseR(Node*& root, const K& key)
    2. {
    3. 	if (root == nullptr)
    4. 	{
    5. 		return false;
    6. 	}
    7.  
    8. 	//先找到要删除的位置
    9. 	if (root->_key < key)
    10. 	{
    11. 		return _EraseR(root->_right, key);
    12. 	}
    13. 	else if (root->_key > key)
    14. 	{
    15. 		return _EraseR(root->_left, key);
    16. 	}
    17. 	else
    18. 	{
    19. 		Node* del = root;
    20.  
    21. 		if (root->_right == nullptr)
    22. 		{
    23. 			root = root->_left;
    24. 		}
    25. 		else if (root->_left == nullptr)
    26. 		{
    27. 			root = root->_right;
    28. 		}
    29. 		else
    30. 		{
    31. 			Node* minRight = root->_right;
    32. 			while (minRight->_left)
    33. 			{
    34. 				minRight = minRight->_left;
    35. 			}
    36.  
    37. 			swap(root->_key, minRight->_key);
    38.  
    39. 			//转换为在子树中删除节点
    40.  
    41. 			return _EraseR(root->_right, key);
    42. 		}
    43. 		delete del;
    44. 		return true;
    45. 	}
    46. }

     5、完整代码实现

    1. namespace K
    2. {
    3. 	template<class K>
    4. 	struct BSTreeNode
    5. 	{
    6. 		BSTreeNode* _left;
    7. 		BSTreeNode* _right;
    8. 		K _key;
    9.  
    10. 		BSTreeNode(const K& key)
    11. 			:_key(key)
    12. 			, _left(nullptr)
    13. 			, _right(nullptr)
    14. 		{}
    15. 	};
    16.  
    17. 	template<class K>
    18. 	class BSTree
    19. 	{
    20. 		typedef BSTreeNode Node;
    21. 	public:
    22.  
    23. 		//默认构造
    24. 		BSTree()
    25. 			:_root(nullptr)
    26. 		{}
    27.  
    28. 		//构造函数
    29. 		BSTree(const BSTree& t)
    30. 		{
    31. 			_root = Copy(t._root);
    32. 		}
    33.  
    34. 		//赋值重载
    35. 		BSTree& operator=(BSTree t)
    36. 		{
    37. 			swap(_root, t._root);
    38. 			return *this;
    39. 		}
    40.  
    41. 		//析构函数
    42. 		~BSTree()
    43. 		{
    44. 			Destroy(_root);
    45. 			_root = nullptr;
    46. 		}
    47. 		//搜索二插树插入
    48. 		bool Inert(const K& key)
    49. 		{
    50. 			if (_root == nullptr)
    51. 			{
    52. 				_root = new Node(key);
    53. 				return true;
    54. 			}
    55.  
    56. 			Node* parent = nullptr;
    57. 			Node* cur = _root;
    58. 			//遍历树，找插入位置
    59. 			while (cur)
    60. 			{
    61. 				if (cur->_key > key)
    62. 				{
    63. 					parent = cur;
    64. 					cur = cur->_left;
    65. 				}
    66. 				else if (cur->_key < key)
    67. 				{
    68. 					parent = cur;
    69. 					cur = cur->_right;
    70. 				}
    71. 				else
    72. 				{
    73. 					return false;
    74. 				}
    75. 			}
    76. 			//创建节点
    77. 			cur = new Node(key);
    78.  
    79. 			//连接树
    80. 			if (parent->_key > key)
    81. 			{
    82. 				parent->_left = cur;
    83. 			}
    84. 			else
    85. 			{
    86. 				parent->_right = cur;
    87. 			}
    88. 			return true;
    89. 		}
    90.  
    91.  
    92.  
    93. 		//查找
    94. 		bool Find(const K& key)
    95. 		{
    96. 			Node* cur = _root;
    97. 			while (cur)
    98. 			{
    99. 				if (cur->_key > key)
    100. 				{
    101. 					cur = cur->_left;
    102. 				}
    103. 				else if (cur->_key < key)
    104. 				{
    105. 					cur = cur->_right;
    106. 				}
    107. 				else
    108. 				{
    109. 					return true;
    110. 				}
    111. 			}
    112. 			return false;
    113. 		}
    114.  
    115. 		//删除
    116. 		bool Erase(const K& key)
    117. 		{
    118. 			Node* parent = nullptr;
    119. 			Node* cur = _root;
    120. 			while (cur)
    121. 			{
    122. 				//先找到要删除的数
    123. 				if (cur->_key > key)
    124. 				{
    125. 					parent = cur;
    126. 					cur = cur->_left;
    127. 				}
    128. 				else if (cur->_key < key)
    129. 				{
    130. 					parent = cur;
    131. 					cur = cur->_right;
    132. 				}
    133. 				else
    134. 				{
    135. 					//1、左为空
    136. 					//2、右为空
    137. 					// 1.2都可以直接删除
    138. 					//在直接删除前，我们还要做好cur的左右节点的链接工作，并处理特殊情况(cur==_root)
    139. 					if (cur->_left == nullptr)
    140. 					{
    141. 						//处理特殊情况
    142. 						if (cur == _root)
    143. 						{
    144. 							_root = cur->_right;
    145. 						}
    146. 						else
    147. 						{
    148. 							if (parent->_left == cur)
    149. 							{
    150. 								parent->_left = cur->_right;
    151. 							}
    152. 							else
    153. 							{
    154. 								parent->_right = cur->_right;
    155. 							}
    156. 						}
    157. 						delete cur;
    158. 					}
    159. 					else if (cur->_right == nullptr)
    160. 					{
    161. 						//处理特殊情况
    162. 						if (cur == _root)
    163. 						{
    164. 							_root = cur->_left;
    165. 						}
    166. 						else
    167. 						{
    168. 							if (parent->_left == cur)
    169. 							{
    170. 								parent->_left = cur->_left;
    171. 							}
    172. 							else
    173. 							{
    174. 								parent->_right = cur->_left;
    175. 							}
    176. 						}
    177. 						delete cur;
    178. 					}
    179. 					//3、左右都不为空
    180. 					//找cur右子数的最小节点
    181. 					else
    182. 					{
    183. 						Node* parent = cur;
    184. 						Node* minRight = cur->_right;
    185. 						while (minRight->_left)
    186. 						{
    187. 							parent = minRight;
    188. 							minRight = minRight->_left;
    189. 						}
    190.  
    191. 						cur->_key = minRight->_key;
    192.  
    193. 						//连接
    194. 						if (parent->_left == minRight)
    195. 						{
    196. 							parent->_left = minRight->_right;
    197. 						}
    198. 						else
    199. 						{
    200. 							parent->_right = minRight->_right;
    201. 						}
    202.  
    203. 						//删除节点
    204. 						delete minRight;
    205. 					}
    206.  
    207. 					return true;
    208. 				}
    209. 			}
    210.  
    211. 			return false;
    212. 		}
    213.  
    214. 		void InOrder()
    215. 		{
    216. 			_InOrder(_root);
    217. 			cout << endl;
    218. 		}
    219.  
    220. 		bool InsertR(const K& key)
    221. 		{
    222. 			return _InsertR(_root, key);
    223. 		}
    224.  
    225. 		bool FindR(const K& key)
    226. 		{
    227. 			return _FindR(_root, key);
    228. 		}
    229.  
    230. 		bool EraseR(const K& key)
    231. 		{
    232. 			return _EraseR(_root, key);
    233. 		}
    234. 		//递归写法完成增删查改
    235. 	private:
    236.  
    237. 		void Destroy(Node* root)
    238. 		{
    239. 			if (root == nullptr)
    240. 			{
    241. 				return;
    242. 			}
    243.  
    244. 			Destroy(root->_left);
    245. 			Destroy(root->_right);
    246. 			delete root;
    247. 		}
    248.  
    249. 		//拷贝节点
    250. 		Node* Copy(Node* root)
    251. 		{
    252. 			if (root == nullptr)
    253. 			{
    254. 				return nullptr;
    255. 			}
    256.  
    257. 			Node* newRoot = new Node(root->_key);
    258. 			newRoot->_left = Copy(root->_left);
    259. 			newRoot->_right = Copy(root->_right);
    260.  
    261. 			return newRoot;
    262. 		}
    263.  
    264. 		void _InOrder(Node* root)
    265. 		{
    266. 			if (root == nullptr)
    267. 				return;
    268.  
    269. 			_InOrder(root->_left);
    270. 			cout << root->_key << " ";
    271. 			_InOrder(root->_right);
    272. 		}
    273.  
    274. 		bool _InsertR(Node*& root, const K& key)
    275. 		{
    276. 			if (root == nullptr)
    277. 			{
    278. 				root = new Node(key);
    279. 				return true;
    280. 			}
    281.  
    282. 			if (root->_key < key)
    283. 			{
    284. 				return _InsertR(root->_right, key);
    285. 			}
    286. 			else if (root->_key > key)
    287. 			{
    288. 				return _InsertR(root->_left, key);
    289. 			}
    290. 			else
    291. 			{
    292. 				return false;
    293. 			}
    294. 		}
    295.  
    296. 		bool _FindR(Node* root, const K& key)
    297. 		{
    298. 			if (root == nullptr)
    299. 			{
    300. 				return false;
    301. 			}
    302.  
    303. 			if (root->_key < key)
    304. 			{
    305. 				return _FindR(root->_right, key);
    306. 			}
    307. 			else if (root->_key > key)
    308. 			{
    309. 				return _FindR(root->_left, key);
    310. 			}
    311. 			else
    312. 			{
    313. 				return true;
    314. 			}
    315. 		}
    316.  
    317. 		bool _EraseR(Node*& root, const K& key)
    318. 		{
    319. 			if (root == nullptr)
    320. 			{
    321. 				return false;
    322. 			}
    323.  
    324. 			//先找到要删除的位置
    325. 			if (root->_key < key)
    326. 			{
    327. 				return _EraseR(root->_right, key);
    328. 			}
    329. 			else if (root->_key > key)
    330. 			{
    331. 				return _EraseR(root->_left, key);
    332. 			}
    333. 			else
    334. 			{
    335. 				Node* del = root;
    336.  
    337. 				if (root->_right == nullptr)
    338. 				{
    339. 					root = root->_left;
    340. 				}
    341. 				else if (root->_left == nullptr)
    342. 				{
    343. 					root = root->_right;
    344. 				}
    345. 				else
    346. 				{
    347. 					Node* minRight = root->_right;
    348. 					while (minRight->_left)
    349. 					{
    350. 						minRight = minRight->_left;
    351. 					}
    352.  
    353. 					swap(root->_key, minRight->_key);
    354.  
    355. 					//转换为在子树中删除节点
    356.  
    357. 					return _EraseR(root->_right, key);
    358. 				}
    359. 				delete del;
    360. 				return true;
    361. 			}
    362. 		}
    363.  
    364. 	private:
    365. 		Node* _root = nullptr;
    366. 	};
    367. }

    三、二叉搜索树的应用

    1、K模型

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

    这里就是我们完整实现的二叉树，这里我们用二叉搜索树的查找功能，如果该单词存在树中就会返回true，否则返回false。

    2、KV模型

    KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方 式在现实生活中非常常见：

    • 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英 文单词与其对应的中文就构成一种键值对；
    • 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出 现次数就是就构成一种键值对。

    这里我们上面代码进行简单改造就可以得到我们的KV模型：

    1. namespace KV
    2. {
    3. 	template<class K, class V>
    4. 	struct BSTreeNode
    5. 	{
    6. 		BSTreeNode* _left;
    7. 		BSTreeNode* _right;
    8. 		K _key;
    9. 		V _value;
    10.  
    11. 		BSTreeNode(const K& key, const V& value)
    12. 			:_key(key)
    13. 			, _value(value)
    14. 			, _left(nullptr)
    15. 			, _right(nullptr)
    16. 		{}
    17. 	};
    18.  
    19. 	//BSTree> bookInfo;
    20.  
    21. 	template<class K, class V>
    22. 	class BSTree
    23. 	{
    24. 		typedef BSTreeNode Node;
    25. 	public:
    26. 		bool Insert(const K& key, const V& value)
    27. 		{
    28. 			if (_root == nullptr)
    29. 			{
    30. 				_root = new Node(key, value);
    31. 				return true;
    32. 			}
    33.  
    34. 			Node* parent = nullptr;
    35. 			Node* cur = _root;
    36. 			while (cur)
    37. 			{
    38. 				if (cur->_key < key)
    39. 				{
    40. 					parent = cur;
    41. 					cur = cur->_right;
    42. 				}
    43. 				else if (cur->_key > key)
    44. 				{
    45. 					parent = cur;
    46. 					cur = cur->_left;
    47. 				}
    48. 				else
    49. 				{
    50. 					return false;
    51. 				}
    52. 			}
    53.  
    54. 			cur = new Node(key, value);
    55. 			if (parent->_key < key)
    56. 			{
    57. 				parent->_right = cur;
    58. 			}
    59. 			else
    60. 			{
    61. 				parent->_left = cur;
    62. 			}
    63.  
    64. 			return true;
    65. 		}
    66.  
    67. 		Node* Find(const K& key)
    68. 		{
    69. 			Node* cur = _root;
    70. 			while (cur)
    71. 			{
    72. 				if (cur->_key < key)
    73. 				{
    74. 					cur = cur->_right;
    75. 				}
    76. 				else if (cur->_key > key)
    77. 				{
    78. 					cur = cur->_left;
    79. 				}
    80. 				else
    81. 				{
    82. 					return cur;
    83. 				}
    84. 			}
    85.  
    86. 			return nullptr;
    87. 		}
    88.  
    89. 		void Inorder()
    90. 		{
    91. 			_Inorder(_root);
    92. 		}
    93.  
    94. 		void _Inorder(Node* root)
    95. 		{
    96. 			if (root == nullptr)
    97. 				return;
    98.  
    99. 			_Inorder(root->_left);
    100. 			cout << root->_key << ":" << root->_value << endl;
    101. 			_Inorder(root->_right);
    102. 		}
    103. 	private:
    104. 		Node* _root = nullptr;
    105. 	};
    106. }
    107.  
    108. void TestBSTree2()
    109. {
    110. // Key/Value的搜索模型,通过Key查找或修改Valu
    111. 	KV::BSTree dict;
    112. 	dict.Insert("sort", "排序");
    113. 	dict.Insert("string", "字符串");
    114. 	dict.Insert("left", "左边");
    115. 	dict.Insert("right", "右边");
    116.  
    117. 	string str;
    118. 	while (cin >> str)
    119. 	{
    120. 		KV::BSTreeNode* ret = dict.Find(str);
    121. 		if (ret)
    122. 		{
    123. 			cout << ret->_value << endl;
    124. 		}
    125. 		else
    126. 		{
    127. 			cout << "无此单词" << endl;
    128. 		}
    129. 	}
    130. }

    这里我们对改造的二叉搜索树，就可以进行通过英文快速找到英文。

  • 相关阅读:
    Devart dotConnect ADO.NET Data Providers Crack
    Linux网络通信编程（套接字模型TCP\UDP与IO多路复用模型select\poll\epoll）
    4.9 nodejs操作多种数据库
    Jmeter 逻辑控制之IF条件控制器
    基于Java+SpringBoot+Thymeleaf+Mysql在线外卖点餐系统设计与实现
    数字花园的指南针：微信小程序排名的提升之道
    RedisTemplate常用方法（超详细）
    字节序详细解读
    Cisco.Packet.Tracer思科模拟器浮动路由讲解（含实例步骤）
    redis -- 数据类型及操作
  • 原文地址：https://blog.csdn.net/qq_61552595/article/details/133999046