• 【C++】二叉树进阶 -- 详解

    一、二叉搜索树概念

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

    • 对二叉搜索树进行中序遍历，正好是一个升序序列。（左子树 -> 根 -> 右子树）

    二、二叉搜索树操作

    • 增删查的时间复杂度是：O（h）。h 是树的高度，最坏情况是 h 是 N。

    int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

    1、二叉搜索树的查找

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

    2、二叉搜索树的插入

    插入的具体过程如下：
    • 树为空，则直接新增节点，赋值给 root 指针。
    • 树不空，按二叉搜索树性质查找插入位置，插入新节点。

    3、搜索二叉搜索树的删除

    首先查找元素是否在二叉搜索树中，如果不存在，则返回，否则要删除的结点可能分下面四种情况：
    1. 要删除的结点无孩子结点。
    2. 要删除的结点只有左孩子结点。
    3. 要删除的结点只有右孩子结点。
    4. 要删除的结点有左、右孩子结点。

    看起来有待删除节点有 4 种情况，实际情况 a 可以与情况 b/c 合并起来，因此真正的删除过程如下：

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

    删除 3（删除的节点有两个孩子）替换法 -- 删除（以下两种方法任选一种）

    1. 左子树的最大节点 —— 2（左子树的最右节点）
    2. 右子树的最小节点 —— 4（右子树的最左节点）
    • 替换节点赋值给删除节点后，删除替换节点。
    • 替换节点要么没有孩子，要么只有一个孩子，可以直接删除。

    三、二叉搜索树的实现

    1. template<class K>
    2. struct BSTreeNode
    3. {
    4.     BSTreeNode* _left;
    5.     BSTreeNode* _right;
    6.     K _key;
    7.  
    8.     BSTreeNode(const K& key)
    9.         : _left(nullptr)
    10.         , _right(nullptr)
    11.         , _key(key)
    12.     {}    
    13. };
    14.  
    15. template<class K>
    16. class BSTree
    17. {
    18.     typedef BSTreeNode Node;
    19. public:
    20.     bool Insert(const K& key)
    21.     {
    22.         // 如果树为空，直接插入
    23.         if (nullptr == _root)
    24.         {
    25.             _root = new Node(key);
    26.             return true;
    27.         }
    28.  
    29.         // 按照二叉搜索树的性质查找key在树中的插入位置
    30.         Node* cur = _root;
    31.         // 记录cur的双亲，因为新元素最终插入在cur双亲左右孩子的位置
    32.         Node* parent = nullptr;
    33.         while (cur)
    34.         {
    35.             parent = cur;
    36.             if (key < cur->_key)
    37.             {
    38.                 parent = cur;
    39.                 cur = cur->_left;
    40.             }
    41.             else if (key > cur->_key)
    42.             {
    43.                 parent = cur;
    44.                 cur = cur->_right;
    45.             }
    46.             else
    47.                 return false;
    48.         }
    49.  
    50.         // 插入元素
    51.         cur = new Node(key);
    52.         if (key < parent->_key)
    53.             parent->_left = cur;
    54.         else
    55.             parent->_right = cur;
    56.  
    57.         return true;
    58.     }
    59.  
    60.     // 根据二叉搜索树的性质查找：找到值为key的节点在二叉搜索树中的位置
    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. 		return false;
    80.     }
    81.  
    82.     bool Erase(const K& key)
    83.     {
    84.         // 如果树为空，删除失败
    85.         if (nullptr == _root)
    86.             return false;
    87.  
    88.         // 查找在data在树中的位置
    89.         Node* cur = _root;
    90.         Node* parent = nullptr;
    91.         while (cur)
    92.         {
    93.             if (key < cur->_key)
    94.             {
    95.                 parent = cur;
    96.                 cur = cur->_left;
    97.             }
    98.             else if(key > cur->_key)
    99.             {
    100.                 parent = cur;
    101.                 cur = cur->_right;
    102.             }
    103.             else
    104.             {
    105.                 // 开始删除
    106. 				// 1、左为空
    107. 				if (cur->_left == nullptr)
    108. 				{
    109. 					if (cur == _root)
    110. 					{
    111. 						_root = cur->_right;
    112. 					}
    113. 					else
    114. 					{
    115. 						if (cur == parent->_left)
    116. 						{
    117. 							parent->_left = cur->_right;
    118. 						}
    119. 						else
    120. 						{
    121. 							parent->_right = cur->_right;
    122. 						}
    123. 					}
    124. 					delete cur;
    125. 					cur = nullptr;
    126. 				}
    127. 				// 2、右为空
    128. 				else if (cur->_right == nullptr)
    129. 				{
    130. 					if (_root == cur)
    131. 					{
    132. 						_root = cur->_left;
    133. 					}
    134. 					else
    135. 					{
    136. 						if (cur == parent->_left)
    137. 						{
    138. 							parent->_left = cur->_left;
    139. 						}
    140. 						else
    141. 						{
    142. 							parent->_right = cur->_left;
    143. 						}
    144. 					}
    145. 					delete cur;
    146. 					cur = nullptr;
    147. 				}
    148. 				// 3、左右都不为空
    149. 				else
    150. 				{
    151. 					// 找到右子树最小节点进行替换
    152. 					Node* minParent = cur;
    153. 					Node* min = cur->_right;
    154. 					while (min->_left)
    155. 					{
    156. 						minParent = min;
    157. 						min = min->_left;
    158. 					}
    159. 					swap(cur->_key, min->_key);
    160. 					if (minParent->_left == min)
    161. 						minParent->_left = min->_right;
    162. 					else
    163. 						minParent->_right = min->_right;
    164. 					delete min;
    165. 				}
    166. 				return true;
    167.             }
    168.         }
    169.         return false;
    170.     }
    171.  
    172.         // key不在二叉搜索树中，无法删除
    173.         if (nullptr == cur)
    174.             return false;
    175.  
    176.         // 分以下情况进行删除
    177.         if (nullptr == cur->_right)
    178.         {
    179.             // 当前节点只有左孩子或者左孩子为空---可直接删除
    180.         }
    181.         else if (nullptr == cur->_right)
    182.         {
    183.             // 当前节点只有右孩子---可直接删除
    184.         }
    185.         else
    186.         {
    187.             // 当前节点左右孩子都存在，直接删除不好删除，可以在其子树中找一个替代结点，比如：
    188.             // 找其左子树中的最大节点，即左子树中最右侧的节点，或者在其右子树中最小的节点，即右子树中最小的节点
    189.             // 替代节点找到后，将替代节点中的值交给待删除节点，转换成删除替代节点
    190.         }
    191.         return true;
    192.     }
    193.  
    194.     void InOrder()
    195. 	{
    196. 		_InOrder(_root);
    197. 		cout << endl;
    198. 	}
    199.  
    200. 	bool FindR(const K& key)
    201. 	{
    202. 		return _FindR(_root, key);
    203. 	}
    204.  
    205. 	bool InsertR(const K& key)
    206. 	{
    207. 		return _InsertR(_root, key);
    208. 	}
    209.  
    210. 	bool EraseR(const K& key)
    211. 	{
    212. 		return _EraseR(_root, key);
    213. 	}
    214.  
    215. 	~BSTree()
    216. 	{
    217. 		_Destory(_root);
    218. 	}
    219.  
    220.     BSTree() = default;
    221.  
    222. 	BSTree(const BSTree& t)
    223. 	{
    224. 		_root = _Copy(t._root);
    225. 	}
    226.  
    227. 	// t2 = t1
    228. 	BSTree& operator=(BSTree t)
    229. 	{
    230. 		swap(_root, t._root);
    231. 		return *this;
    232. 	}
    233.  
    234. private:
    235.     Node* _Copy(Node* root)
    236. 	{
    237. 		if (root == nullptr)
    238. 		{
    239. 			return nullptr;
    240. 		}
    241.  
    242. 		Node* copyRoot = new Node(root->_key);
    243. 		copyRoot->_left = _Copy(root->_left);
    244. 		copyRoot->_right = _Copy(root->_right);
    245. 		return copyRoot;
    246. 	}
    247.  
    248. 	void _Destory(Node*& root)
    249. 	{
    250. 		if (root == nullptr)
    251. 		{
    252. 			return;
    253. 		}
    254.  
    255. 		_Destory(root->_left);
    256. 		_Destory(root->_right);
    257. 		delete root;
    258. 		root = nullptr;
    259. 	}
    260.  
    261. 	bool _EraseR(Node*& root, const K& key)
    262. 	{
    263. 		if (root == nullptr)
    264. 			return false;
    265.  
    266. 		if (root->_key < key)
    267. 			return _EraseR(root->_right, key);
    268. 		else if (root->_key > key)
    269. 			return _EraseR(root->_left, key);
    270. 		else
    271. 		{
    272. 			Node* del = root;
    273. 			if (root->_left == nullptr)
    274. 			{
    275. 				root = root->_right;
    276. 			}
    277. 			else if (root->_right == nullptr)
    278. 			{
    279. 				root = root->_left;
    280. 			}
    281. 			else
    282. 			{
    283. 				// 找右树的最左节点替换删除
    284. 				Node* min = root->_right;
    285. 				while (min->_left)
    286. 				{
    287. 					min = min->_left;
    288. 				}
    289. 				swap(root->_key, min->_key);
    290. 				//return Erase(key); // 错误 - 找到的不是我们要的位置
    291. 				return _EraseR(root->_right, key);
    292. 			}
    293. 			delete del;
    294. 			return true;
    295. 		}
    296. 	}
    297.  
    298. 	bool _InsertR(Node*& root, const K& key)
    299.     {
    300. 		if (root == nullptr)
    301. 		{
    302. 			root = new Node(key);
    303. 			return true;
    304. 		}
    305.  
    306. 		if (root->_key < key)
    307. 			return _InsertR(root->_right, key);
    308. 		else if (root->_key > key)
    309. 			return _InsertR(root->_left, key);
    310. 		else
    311. 			return false;
    312. 	}
    313.  
    314. 	bool _FindR(Node* root, const K& key)
    315. 	{
    316. 		if (root == nullptr)
    317. 			return false;
    318.  
    319. 		if (root->_key < key)
    320. 			return _FindR(root->_right, key);
    321. 		else if (root->_key > key)
    322. 			return _FindR(root->_left, key);
    323. 		else
    324. 			return true;
    325. 	}
    326.  
    327. 	void _InOrder(Node* root)
    328. 	{
    329. 		if (root == nullptr)
    330. 		{
    331. 			return;
    332. 		}
    333.  
    334. 		_InOrder(root->_left);
    335. 		cout << root->_key << " ";
    336. 		_InOrder(root->_right);
    337. 	}
    338.  
    339. private:
    340. 	Node* _root = nullptr;
    341. };

    四、二叉搜索树的应用

    1、 K模型（判断关键字在不在） ：K 模型即只有 key 作为关键码，结构中只需要存储 Key 即可，关键码即为需要搜索到 的值。
    比如：给一个单词 word，判断该单词是否拼写正确，具体方式如下：
    • 以词库中所有单词集合中的每个单词作为 key，构建一棵二叉搜索树。
    • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
    2、 KV模型 ：每一个关键码 key，都有与之对应的值 Value，即 的键值对。该种方式在现实生活中非常常见：
    比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
    文单词与其对应的中文 就构成一种键值对；
    再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
    现次数就是 就构成一种键值对。 
    1. // 改造二叉搜索树为KV结构
    2. template<class K, class V>
    3. struct BSTreeNode
    4. {
    5.     BSTreeNode* _left;
    6.     BSTreeNode* _right;
    7.     K _key;
    8.     V _value
    10.     BSTreeNode(const K& key, const V& value)
    11.         : _left(nullptr)
    12.         , _right(nullptr)
    13.         , _key(key)
    14.         , _Value(value)
    15.     {}
    16. };
    17.  
    18. template<class K, class V>
    19. class BSTree
    20. {
    21.     typedef BSTNode Node;
    22. public:
    23.     bool Insert(const K& key, const V& value)
    24. 	{
    25. 		if (_root == nullptr)
    26. 		{
    27. 			_root = new Node(key, value);
    28. 			return true;
    29. 		}
    30.  
    31. 		Node* parent = nullptr;
    32. 		Node* cur = _root;
    33. 		while (cur)
    34. 		{
    35. 			if (cur->_key < key)
    36. 			{
    37. 				parent = cur;
    38. 				cur = cur->_right;
    39. 			}
    40. 			else if (cur->_key > key)
    41. 			{
    42. 				parent = cur;
    43. 				cur = cur->_left;
    44. 			}
    45. 			else
    46. 			{
    47. 				return false;
    48. 			}
    49. 		}
    50.  
    51. 		cur = new Node(key, value);
    52. 		if (parent->_key < key)
    53. 		{
    54. 			parent->_right = cur;
    55. 		}
    56. 		else
    57. 		{
    58. 			parent->_left = cur;
    59. 		}
    60. 		return true;
    61. 	}
    62.  
    63. 	Node* Find(const K& key)
    64. 	{
    65. 		Node* cur = _root;
    66. 		while (cur)
    67. 		{
    68. 			if (cur->_key < key)
    69. 			{
    70. 				cur = cur->_right;
    71. 			}
    72. 			else if (cur->_key > key)
    73. 			{
    74. 				cur = cur->_left;
    75. 			}
    76. 			else
    77. 			{
    78. 				return cur;
    79. 			}
    80. 		}
    81. 		return nullptr;
    82. 	}
    83.  
    84. 	bool Erase(const K& key)
    85. 	{
    86. 		Node* parent = nullptr;
    87. 		Node* cur = _root;
    88.  
    89. 		// 查找是否有待删除的节点
    90. 		while (cur)
    91. 		{
    92. 			if (cur->_key < key)
    93. 			{
    94. 				parent = cur;
    95. 				cur = cur->_right;
    96. 			}
    97. 			else if (cur->_key > key)
    98. 			{
    99. 				parent = cur;
    100. 				cur = cur->_left;
    101. 			}
    102. 			else // 开始删除
    103. 			{
    104. 				// 1、左为空
    105. 				if (cur->_left == nullptr)
    106. 				{
    107. 					// 判断当前节点是否为_root，如果是，则无法用parent(当前为nullptr，防止野指针错误)
    108. 					if (cur == _root)
    109. 					{
    110. 						_root = cur->_right;
    111. 					}
    112. 					else
    113. 					{
    114. 						if (cur == parent->_left)
    115. 						{
    116. 							parent->_left = cur->_right;
    117. 						}
    118.                         else
    119. 						{
    120. 							parent->_right = cur->_right;
    121. 						}
    122. 					}
    123. 					delete cur;
    124. 					cur = nullptr;
    125. 				}
    126. 				// 2、右为空
    127. 				else if (cur->_right == nullptr)
    128. 				{
    129. 					if (_root == cur)
    130. 					{
    131. 						_root = cur->_left;
    132. 					}
    133. 					else
    134. 					{
    135. 						if (cur == parent->_left)
    136. 						{
    137. 							parent->_left = cur->_left;
    138. 						}
    139. 						else
    140. 						{
    141. 							parent->_right = cur->_left;
    142. 						}
    143. 					}
    144. 					delete cur;
    145. 					cur = nullptr;
    146. 				}
    147. 				// 3、左右都不为空
    148. 				else
    149. 				{
    150. 					// 记录删除节点父节点
    151. 					Node* minParent = cur; 
    152.  
    153. 					// 找到右子树最小节点进行替换
    154. 					Node* min = cur->_right;
    155. 					while (min->_left)
    156. 					{
    157. 						minParent = min;
    158. 						min = min->_left;
    159. 					}
    160. 					swap(cur->_key, min->_key);
    161.  
    162. 					// min在父的左孩子上
    163. 					if (minParent->_left == min)
    164. 					{
    165. 						// 万一最左节点还有右孩子节点，或者是叶子也直接指右为空
    166. 						minParent->_left = min->_right;
    167. 					}
    168. 					// min在父的右孩子上（待删除节点在根节点，最左节点为根节点的右孩子）
    169. 					else
    170. 					{
    171. 						minParent->_right = min->_right;
    172. 					}
    173. 					delete min;
    174. 					min == nullptr;
    175. 				}
    176. 				return true;
    177. 			}
    178. 		}
    179. 		return false;
    180. 	}
    181.  
    182. 	void InOrder()
    183. 	{
    184. 		_InOrder(_root);
    185. 		cout << endl;
    186. 	}
    187. private:
    188. 	void _InOrder(Node* root)
    189. 	{
    190. 		if (root == nullptr)
    191. 		{
    192. 			return;
    193. 		}
    194.  
    195. 		_InOrder(root->_left);
    196. 		cout << root->_key << ":" << root->_value << endl;
    197. 		_InOrder(root->_right);
    198. 	}
    199. private:
    200. 	Node* _root = nullptr;
    201. };
    202.  
    203. void TestBSTree1()
    204. {
    205.     // 输入单词，查找单词对应的中文翻译
    206.     BSTree dict;
    207.     dict.Insert("string", "字符串");
    208.     dict.Insert("tree", "树");
    209.     dict.Insert("left", "左边");
    210.     dict.Insert("right", "右边");
    211.     dict.Insert("sort", "排序");
    212.     // 插入词库中所有单词
    213.     string str;
    214.     while (cin >> str)
    215.     {
    216.         BSTreeNode* ret = dict.Find(str);
    217.         if (ret)
    218. 		{
    219. 			cout << "对应的中文:" << ret->_value << endl;
    220. 		}
    221. 		else
    222. 		{
    223. 			cout << "没有此单词" << endl;
    224. 		}
    225.     }
    226. }
    227.  
    228. void TestBSTree2()
    229. {
    230.     // 统计水果出现的次数
    231.     string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
    232.     BSTreeint> countTree;
    233.     for (const auto& str : arr)
    234.     {
    235.         // 先查找水果在不在搜索树中
    236.         // 1、不在，说明水果第一次出现，则插入<水果, 1>
    237.         // 2、在，则查找到的节点中水果对应的次数++
    238.         //BSTreeNode* ret = countTree.Find(str);
    239.         auto ret = countTree.Find(str);
    240.         if (ret)
    241. 		{
    242. 			ret->_value++;
    243. 		}
    244. 		else
    245. 		{
    246. 			countTree.Insert(str, 1);
    247. 		}
    248.     }
    249.     countTree.InOrder();
    250. }

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

    插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
    对有 n 个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
    但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

    1. 最优情况下，二叉搜索树为完全二叉树（或者接近完全二叉树），其平均比较次数为： logN。
    2. 最差情况下，二叉搜索树退化为单支树（或者类似单支），其平均比较次数为：N。
    如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？
    那么我们后面将学习的 AVL 树和红黑树 就可以派上用场了。
  • 相关阅读:
    GEE入门篇|图像处理（二）：在Earth Engine中进行波段计算
    腾讯云服务器选购指南：如何选择一台合适的云服务器配置？
    使用shuffle sharding增加容错性
    功能强大的开源数据中台系统 DataCap 2024.03.3 发布
    驱动开发LED灯绑定设备文件
    OpenCV项目开发实战--详细介绍如何进行图像平移和旋转含原理讲解+实现源码
    java毕业设计基于互联网的图书管理系统—借阅管理子模块（附源码、数据库）
    如何高效系统学习 MySQL?
    数据结构之图（基本操作）
    Flutter 常见错误记录总结
  • 原文地址：https://blog.csdn.net/weixin_74531333/article/details/133816987