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

    在这里插入图片描述

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

    在这里插入图片描述

    文章目录

    前言

    一.概念：

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

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

    二.二叉树的实现

    1.0版本（循环版本）：

    1. 二叉搜索树的查找

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

    2. 二叉搜索树的插入

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

    3. 二叉搜索树的删除

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

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

    • 左为空：
      a1.父节点和删除结点如果重合，直接让root指向删除结点的右边

      a2父节点指向删除结点的右边
      在这里插入图片描述

    • 右为空(与上面同理）
      a3 父节点和删除结点如果重合，直接让root指向删除结点的左边
      a4父节点指向删除结点的左边

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

    在这里插入图片描述

    总代码：

    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;
		}
	};
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242

    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);
		}
	};
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186

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

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

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

    递归版本：
    递归版本
    循环版本：
    在这里插入图片描述

    三.搜索二叉树的应用：

    1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
      比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
    • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
    • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
    1. KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方式在现实生活中非常常见：
      比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对；
      再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
      现次数就是就构成一种键值对
      还有就是我们平时刷身份证，平台通过我们身份证号码找到我们相关消息，只不过这个是更复杂的场景。下面我们来看一下具体的应用：

    我们只需要把平常的多加一个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;
		}

	};
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219

    字典的例子：

    void TestBSTree3()
{
	//BSTree 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;
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    统计个数的例子：

    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();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    总结

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

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

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

    在这里插入图片描述

  • 相关阅读:
    三、飞行和射击
    什么情况下适合使用静态路由？什么情况下适合使用动态路由？
    华为od德科面试数据算法解析 2022-8-3 消息队列合并
    （六）React Ant Design Pro + .Net5 WebApi：后端环境搭建-EF Core
    MultipartFile上传文件报文件不存在的几种情况
    中秋节静态HTML网页作业作品 大学生中秋网页设计制作成品 简单DIV CSS布局网站
    信息学奥赛一本通：1161：转进制
    串口转TCP/IP方案选型
    Eureka Server配置
    [附源码]计算机毕业设计springboot课室预约系统
  • 原文地址：https://blog.csdn.net/qq_74310471/article/details/132634629