devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++/数据结构：二叉搜索树的实现与应用

作者：菜鸟追梦旅行 | 2024-02-18 00:08:22

赞

踩

C++/数据结构：二叉搜索树的实现与应用

目录

一、二叉搜索树简介

二、二叉搜索树的结构与实现

2.1二叉树的查找与插入

2.2二叉树的删除

2.3二叉搜索树的实现

2.3.1非递归实现

 2.3.2递归实现

三、二叉搜索树的k模型和kv模型

一、二叉搜索树简介

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

二、二叉搜索树的结构与实现

2.1二叉树的查找与插入

int a [] = { 8 , 3 , 1 , 10 , 6 , 4 , 7 , 14 , 13 };
1. 二叉搜索树的查找
a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。
2. 二叉搜索树的插入
插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

2.2二叉树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下：
情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点
中，再来处理该结点的删除问题--替换法删除。

2.3二叉搜索树的实现

2.3.1非递归实现

  1. //二叉树节点的构建
  2. template<class K>
  3. 	struct BSTreeNode
  4. 	{
  5. 		typedef BSTreeNode<K> Node;
  6.  
  7. 		Node* _left;
  8. 		Node* _right;
  9. 		K _key;
  10.  
  11. 		BSTreeNode(const K& key)
  12. 			:_left(nullptr)
  13. 			, _right(nullptr)
  14. 			, _key(key)
  15. 		{}
  16. 	};
  17.  
  18.  
  19.  
  20. 	//class BinarySearchTree
  21. 	template<class K>
  22. 	class BSTree
  23. 	{
  24. 		typedef BSTreeNode<K> Node;
  25. 	public:
  26. 		// 强制生成默认构造
  27. 		BSTree() = default;
  28.  
  29.         //拷贝构造
  30. 		BSTree(const BSTree<K>& t)
  31. 		{
  32. 			_root = Copy(t._root);
  33. 		}
  34.         
  35.         //赋值拷贝
  36. 		BSTree<K>& operator=(BSTree<K> t)
  37. 		{
  38. 			swap(_root, t._root);
  39. 			return *this;
  40. 		}
  41.  
  42.         //析构函数
  43. 		~BSTree()
  44. 		{
  45. 			Destroy(_root);
  46. 		}
  47.         
  48.         
  49.         ///
  50.         //增删查改
  51.  
  52.         //插入数据
  53. 		bool Insert(const K& key)
  54. 		{
  55. 			if (_root == nullptr)
  56. 			{
  57. 				_root = new Node(key);
  58. 				return true;
  59. 			}
  60.  
  61. 			Node* parent = nullptr;
  62. 			Node* cur = _root;
  63. 			while (cur)
  64. 			{
  65. 				if (cur->_key < key)
  66. 				{
  67. 					parent = cur;
  68. 					cur = cur->_right;
  69. 				}
  70. 				else if (cur->_key > key)
  71. 				{
  72. 					parent = cur;
  73. 					cur = cur->_left;
  74. 				}
  75. 				else
  76. 				{
  77. 					return false;
  78. 				}
  79. 			}
  80.  
  81. 			cur = new Node(key);
  82. 			if (parent->_key < key)
  83. 			{
  84. 				parent->_right = cur;
  85. 			}
  86. 			else
  87. 			{
  88. 				parent->_left = cur;
  89. 			}
  90.  
  91. 			return true;
  92. 		}
  93.  
  94.  
  95.         //查找数据
  96. 		bool Find(const K& key)
  97. 		{
  98. 			Node* cur = _root;
  99. 			while (cur)
  100. 			{
  101. 				if (cur->_key < key)
  102. 				{
  103. 					cur = cur->_right;
  104. 				}
  105. 				else if (cur->_key > key)
  106. 				{
  107. 					cur = cur->_left;
  108. 				}
  109. 				else
  110. 				{
  111. 					return true;
  112. 				}
  113. 			}
  114.  
  115. 			return false;
  116. 		}
  117.  
  118.         //删除数据
  119. 		bool Erase(const K& key)
  120. 		{
  121. 			Node* parent = nullptr;
  122. 			Node* cur = _root;
  123. 			while (cur)
  124. 			{
  125. 				if (cur->_key < key)
  126. 				{
  127. 					parent = cur;
  128. 					cur = cur->_right;
  129. 				}
  130. 				else if (cur->_key > key)
  131. 				{
  132. 					parent = cur;
  133. 					cur = cur->_left;
  134. 				}
  135. 				else
  136. 				{
  137. 					if (cur->_left == nullptr)
  138. 					{
  139. 						if (cur == _root)
  140. 						{
  141. 							_root = cur->_right;
  142. 						}
  143. 						else
  144. 						{
  145. 							if (cur == parent->_right)
  146. 							{
  147. 								parent->_right = cur->_right;
  148. 							}
  149. 							else
  150. 							{
  151. 								parent->_left = cur->_right;
  152. 							}
  153. 						}
  154.  
  155. 						delete cur;
  156. 						return true;
  157. 					}
  158. 					else if (cur->_right == nullptr)
  159. 					{
  160. 						if (cur == _root)
  161. 						{
  162. 							_root = cur->_left;
  163. 						}
  164. 						else
  165. 						{
  166. 							if (cur == parent->_right)
  167. 							{
  168. 								parent->_right = cur->_left;
  169. 							}
  170. 							else
  171. 							{
  172. 								parent->_left = cur->_left;
  173. 							}
  174. 						}
  175.  
  176. 						delete cur;
  177. 						return true;
  178. 					}
  179. 					else
  180. 					{
  181. 						// 替换法
  182. 						Node* rightMinParent = cur;
  183. 						Node* rightMin = cur->_right;
  184. 						while (rightMin->_left)
  185. 						{
  186. 							rightMinParent = rightMin;
  187. 							rightMin = rightMin->_left;
  188. 						}
  189.  
  190. 						cur->_key = rightMin->_key;
  191.  
  192. 						if (rightMin == rightMinParent->_left)
  193. 							rightMinParent->_left = rightMin->_right;
  194. 						else
  195. 							rightMinParent->_right = rightMin->_right;
  196.  
  197. 						delete rightMin;
  198. 						return true;
  199. 					}
  200. 				}
  201. 			}
  202.  
  203. 			return false;
  204. 		}
  205.  
  206.     private：
  207.     Node* _root;
  208.     };

 2.3.2递归实现

  1. //二叉树节点的构建
  2. template<class K>
  3. 	struct BSTreeNode
  4. 	{
  5. 		typedef BSTreeNode<K> Node;
  6.  
  7. 		Node* _left;
  8. 		Node* _right;
  9. 		K _key;
  10.  
  11. 		BSTreeNode(const K& key)
  12. 			:_left(nullptr)
  13. 			, _right(nullptr)
  14. 			, _key(key)
  15. 		{}
  16. 	};
  17.  
  18.  
  19.  
  20. 	//class BinarySearchTree
  21. 	template<class K>
  22. 	class BSTree
  23. 	{
  24. 		typedef BSTreeNode<K> Node;
  25. 	public:
  26. 		// 强制生成默认构造
  27. 		BSTree() = default;
  28.  
  29.         //拷贝构造
  30. 		BSTree(const BSTree<K>& t)
  31. 		{
  32. 			_root = Copy(t._root);
  33. 		}
  34.         
  35.         //赋值拷贝
  36. 		BSTree<K>& operator=(BSTree<K> t)
  37. 		{
  38. 			swap(_root, t._root);
  39. 			return *this;
  40. 		}
  41.  
  42.         //析构函数
  43. 		~BSTree()
  44. 		{
  45. 			Destroy(_root);
  46. 		}
  47.         
  48.         
  49.         ///
  50.         //增删查改
  51.         bool FindR(const K& key)
  52. 		{
  53. 			return _FindR(_root, key);
  54. 		}
  55.  
  56. 		bool InsertR(const K& key)
  57. 		{
  58. 			return _InsertR(_root, key);
  59. 		}
  60.  
  61. 		bool EraseR(const K& key)
  62. 		{
  63. 			return _EraseR(_root, key);
  64. 		}
  65.         void InOrder()
  66. 		{
  67. 			_InOrder(_root);
  68. 			cout << endl;
  69. 		}
  70.  
  71.     private：
  72.     void Destroy(Node* root)
  73. 		{
  74. 			if (root == nullptr)
  75. 				return;
  76.  
  77. 			Destroy(root->_left);
  78. 			Destroy(root->_right);
  79. 			delete root;
  80. 		}
  81.  
  82. 		Node* Copy(Node* root)
  83. 		{
  84. 			if (root == nullptr)
  85. 				return nullptr;
  86.  
  87. 			Node* newRoot = new Node(root->_key);
  88. 			newRoot->_left = Copy(root->_left);
  89. 			newRoot->_right = Copy(root->_right);
  90. 			return newRoot;
  91. 		}
  92.  
  93.         //借助引用可以更好的删除和更改数据节点，不需要再额外创建父节点来更改
  94. 		bool _EraseR(Node*& root, const K& key)
  95. 		{
  96. 			if (root == nullptr)
  97. 				return false;
  98.  
  99. 			if (root->_key < key)
  100. 			{
  101. 				return _EraseR(root->_right, key);
  102. 			}
  103. 			else if (root->_key > key)
  104. 			{
  105. 				return _EraseR(root->_left, key);
  106. 			}
  107. 			else
  108. 			{
  109. 				Node* del = root;
  110. 				if (root->_right == nullptr)
  111. 				{
  112. 					root = root->_left;
  113. 				}
  114. 				else if (root->_left == nullptr)
  115. 				{
  116. 					root = root->_right;
  117. 				}
  118. 				else
  119. 				{
  120. 					Node* rightMin = root->_right;
  121. 					while (rightMin->_left)
  122. 					{
  123. 						rightMin = rightMin->_left;
  124. 					}
  125.  
  126. 					swap(root->_key, rightMin->_key);
  127.  
  128. 					return _EraseR(root->_right, key);
  129. 				}
  130.  
  131. 				delete del;
  132. 				return true;
  133. 			}
  134. 		}
  135.  
  136. 		bool _InsertR(Node*& root, const K& key)
  137. 		{
  138. 			if (root == nullptr)
  139. 			{
  140. 				root = new Node(key);
  141. 				return true;
  142. 			}
  143.  
  144. 			if (root->_key < key)
  145. 			{
  146. 				return _InsertR(root->_right, key);
  147. 			}
  148. 			else if (root->_key > key)
  149. 			{
  150. 				return _InsertR(root->_left, key);
  151. 			}
  152. 			else
  153. 			{
  154. 				return false;
  155. 			}
  156. 		}
  157.  
  158. 		bool _FindR(Node* root, const K& key)
  159. 		{
  160. 			if (root == nullptr)
  161. 				return false;
  162.  
  163. 			if (root->_key < key)
  164. 			{
  165. 				return _FindR(root->_right, key);
  166. 			}
  167. 			else if (root->_key > key)
  168. 			{
  169. 				return _FindR(root->_left, key);
  170. 			}
  171. 			else
  172. 			{
  173. 				return true;
  174. 			}
  175. 		}
  176.  
  177. 		void _InOrder(Node* root)
  178. 		{
  179. 			if (root == nullptr)
  180. 				return;
  181.  
  182. 			_InOrder(root->_left);
  183. 			cout << root->_key << " ";
  184. 			_InOrder(root->_right);
  185. 		}
  186.  
  187.     Node* _root;
  188.     };

三、二叉搜索树的k模型和kv模型

1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到
的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
例如：小区停车场，只要可以搜索到车牌号就可以自由进出。
2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方
式在现实生活中非常常见：
比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
文单词与其对应的中文<word, chinese>就构成一种键值对；
再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
现次数就是<word, count>就构成一种键值对。
例如：商场停车场，进去时记录车牌号，出来时查询是否缴费，如果缴费才可以出去。
改造搜素二叉树为kv结构： 
  1. // 改造二叉搜索树为KV结构
  2. template<class K, class V>
  3. struct BSTNode
  4.  {
  5.  BSTNode(const K& key = K(), const V& value = V())
  6.    : _pLeft(nullptr) , _pRight(nullptr), _key(key), _Value(value)
  7.  {}
  8.  BSTNode<T>* _pLeft;
  9.  BSTNode<T>* _pRight;
  10.  K _key;
  11.     V _value
  12.  };
  13. template<class K, class V>
  14. class BSTree
  15.  {
  16.  typedef BSTNode<K, V> Node;
  17.  typedef Node* PNode;
  18. public:
  19.  BSTree(): _pRoot(nullptr){}
  20.  PNode Find(const K& key);
  21.  bool Insert(const K& key, const V& value)
  22.  bool Erase(const K& key)
  23. private:
  24.  PNode _pRoot;
  25.  };
  26.  
  27.  
  28.  
  29. void TestBSTree()
  30. {
  31.  // 输入单词，查找单词对应的中文翻译
  32.  BSTree<string, string> dict;
  33.  dict.Insert("string", "字符串");
  34.  dict.Insert("tree", "树");
  35.  dict.Insert("left", "左边、剩余");
  36.  dict.Insert("right", "右边");
  37.  dict.Insert("sort", "排序");
  38.  // 插入词库中所有单词
  39.  string str;
  40.  while (cin>>str)
  41.  {
  42.  BSTreeNode<string, string>* ret = dict.Find(str);
  43.  if (ret == nullptr)
  44.  {
  45.  cout << "单词拼写错误，词库中没有这个单词:" <<str <<endl;
  46.  }
  47.  else
  48.  {
  49.  cout << str << "中文翻译:" << ret->_value << endl;
  50.  }
  51.  }
  52. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/102641
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号