【C++】二叉搜索树

最新推荐文章于 2024-05-29 11:03:58 发布
最新推荐文章于 2024-05-29 11:03:58 发布
阅读量792 收藏 16
点赞数 25
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62357106/article/details/136407212
版权

一、二叉搜索树的概念：

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

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

二 、二叉搜索树的操作：

2.1、主体框架：

template<class K>
struct BSTreeNode
{
    BSTreeNode<K>* _left;
    BSTreeNode<K>* _right;
    K _key;

    BSTreeNode(const K& key)
        :_key(key)
            , _left(nullptr)
            , _right(nullptr)
        {}
};

template<class K>
class BSTree
{
    typedef BSTreeNode<K> Node;
public:
    
private:
	Node* _root = nullptr;
};

2.2、中序遍历：

对于二叉搜索树来说，中序遍历就是排好序的形式，如果中序遍历之后需要换行，那可以用子函数的形式完成递归，并放在私有防止直接使用。

2.3、二叉搜索树的查找：

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

2.4、二叉搜索树的插入：

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

2.5、二叉搜索树的删除：（！！！） 

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

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

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来：

1. 删除节点的右为空

2. 删除节点的左为空

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

因此真正的删除过程如下:

  • 情况1：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除。

 

  • 情况2：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除

 

  • 情况3：在它的右子树中寻找中序下的第一个结点(关键码最小，即右子树的最小节点)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除

(或者在他的左子树寻找最右的节点替换，一个道理，但我们以上面的情况演示) 

当然，这几种也都有递归版本，还有一些默认成员函数的实现，由于整体看才能更好理解，因此这些都通过下面的代码形式展示：

三、二叉搜索树的模拟实现：

template<class K>
	struct BSTreeNode
	{
		BSTreeNode<K>* _left;
		BSTreeNode<K>* _right;
		K _key;

		BSTreeNode(const K& key)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};

	template<class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	public:

		BSTree() = default; //指定强制生成的默认构造

		BSTree(const BSTree<K>& t)
		{
			_root = Copy(t._root);
		}

		BSTree<K>& operator=(BSTree<K> t)
		{
			swap(_root, t._root);
			return *this;
		}

		~BSTree()
		{
			Destory(_root);
		}


		bool Insert(const K& key)
		{
			//第一个插入的节点为头节点
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			//寻找目标值应在树的位置
			Node* cur = _root;  //从头节点开始遍历
			Node* parent = nullptr;  //记录目标数节点的父节点，以确保链接
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			//链接
			cur = new Node(key);

			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			return true;
		}

		bool Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else
				{
					return true;
				}
			}
			return false;
		}

		bool Erase(const K& key)
		{
			//先找到要删除节点的位置
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//删除

					//1.被删节点的左节点为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)  //被删节点是一棵“歪脖子树”的根节点，换根即可
						{
							_root = _root->_right;
						}
						else
						{
							if (parent->_left == cur) //被删节点本身在整棵树的左枝，被删节点的左子节点一定比其父节点小
							{
								parent->_left = cur->_left;
							}
							else//被删节点本身在整棵树的右枝，被删节点的右子节点一定比其父节点大
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}//2.被删节点的右节点为空
					else if (cur->_right == nullptr)//同理
					{
						if (cur == _root)  //同上
						{
							_root = _root->_left;
						}
						else
						{
							if (parent->_right == cur)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}
						delete cur;
					}//3.被删节点左右节点都不为空
					else
					{
						// 找右树最小节点替代，也可以是左树最大节点替代
						Node* pminright = cur;
						Node* minright = cur->_right;
						while (minright->_left)
						{
							pminright = minright;
							minright = minright->_left;
						}

						//替换删除
						cur->_key = minright->_key;

						//替换删除后剩余子节点的链接
						if (pminright->_left == minright)
						{
							pminright->_left = minright->_right;
						}
						else
						{
							pminright->_right = minright->_right;
						}

						delete minright;

					}
					return true;
				}
			}
			return false;
		}

		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}

		bool InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}

		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}

		//中序遍历
		void InOrder()
		{
			//对象传参时传不了成员变量，所以采用套用的方式
			//一般在类中有递归的场景都会采用这种方式来调用
			_InOrder(_root);
			cout << endl;
		}


	protected:

		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;
			Node* newRoot = new Node(root->_key);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}

		void Destory(Node*& root)
		{
			if (root == nullptr)
				return;
			Destory(root->_left);
			Destory(root->_right);

			delete root;
			root = nullptr;
		}

		bool FindR(Node* root, const K& key)
		{
			if (root == nullptr)
				return false;
			if (root->_key == key)
				return true;
			if (root->_key < key)
				return _FindR(root->_right, key);
			else
				return _FindR(root->_left, key);
	    }

		bool _InsertR(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(key);  //引用不能改变指针指向，只能赋值
				return true;
			}

			if (root->_key < key)
			{
				return _InsertR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _InsertR(root->_left, key);
			}
			else
			{
				return false;
			}
		}

		bool _EraseR(Node*& root, const K& key)
		{
			if (root == nullptr)
				return false;
			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			else
			{
				Node* del = root;

				if (root->_left == nullptr) //链接被删节点的剩余子节点,root就是被其父节点指向它的指针，修改root即可
				{
					root = root->_right;  
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					//找左子树最大节点替换
					Node* maxleft = root->_left;
					while (maxleft->_right)
					{
						maxleft = maxleft->_right;
					}

					swap(root->_key, maxleft->_key);  //用swap而不是赋值，确保递归子树时，子树中的最大值是key

					return _EraseR(root->_left, key);  //递归到左子树解决，直到上面的两种情况。

				}

				delete del;
				return true;
			}
		}

		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			//中序遍历：左节点->根节点->右节点
			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}




	private:
		Node* _root = nullptr;
	};

四、二叉搜索树的应用：

4.1、K模型：

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

  • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
  • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

这种实现方式通过上面的代码的Find就可以完成，只不过模板参数转化成了string类型。

4.2、KV模型：


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

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

4.3 KV模型代码实现 ：

namespace KV//通过一个值找另一个值key value，也就是map
{
	template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode<K, V>* _left;
		BSTreeNode<K, V>* _right;
		K _key;
		V _value;

		BSTreeNode(const K& key, const V& value)
			:_key(key)
			, _value(value)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};

	//BSTree<string, vector<string>>  字典查找
	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		bool insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}
			Node* cur = _root;
			Node* parent = _root;
			while (cur)
			{
				parent = cur;
				if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			cur = new Node(key, value);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
		}

		void Inorder()
		{
			_Inorder(_root);
		}


		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else
				{
					return cur;
				}
			}
			return nullptr;
		}

	private:

		void _Inorder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_Inorder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_Inorder(root->_right);
		}
		Node* _root = nullptr;
	};
}
  1. 映射查找：
void TestBsTree3()
{
	//词库中单词都放进这个搜索树中
	//Key的搜索模型，判断在不在？
	//场景：检查单词是否正确/车库初入系统/...
	//K::BSTree<string> dict;

	// Key/Value的搜索模型，通过Key查找或修改Value
	KV::BSTree<string, string> dict;
	dict.insert("sort", "排序");
	dict.insert("string", "字符串");
	dict.insert("left", "左边");
	dict.insert("right", "右边");

	string str;
	while (cin >> str)
	{
		KV::BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret)
		{
			cout << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}

ctrl c快捷键结束

2.统计单词次数：

void TestBsTree4()
{
	// 统计水果出现的次数
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	KV::BSTree<string, int> countTree;
	for (auto e : arr)
	{
		auto* ret = countTree.Find(e);
		if (ret == nullptr)
		{
			countTree.insert(e, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.Inorder();
}

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

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

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

 

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上场了。 

Jaegerttk
关注
  • 25
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
C++二叉搜索树的插入和删除例子
05-29
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任何一个节点，其左子树中的...
C++二叉搜索树
默的博客
05-05 568
C++二叉搜索树1、概念2、操作2.1增加（插入）2.2删除2.3查找2.4修改3、 二叉搜索树的性能分析4、模拟实现代码 1、概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树。 2、操作 2.1增加（插入） 树为空，直接插入，返回true； 树不为空，判断根节点数据大小，根数据大往左边找，否则往右边找，找到返回true；
C++ 二叉搜索树BinarySearchTree
冰果滴的博客
07-30 998
二叉搜索树是为学习map和set做的铺垫，了解了二叉搜索树的特性，有助于更好的理解map和set。
C++ 二叉搜索树 详细讲解
最新发布
foodsx的博客
05-29 955
C++ 二叉搜索树 详细讲解
C++ 之二叉搜索树
qq_74732628的博客
04-24 591
详解c++ 二叉搜索树的实现以及功能
C++ 二叉搜索树
m0_61548909的博客
07-23 589
或者是具有以下性质的二叉树若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树。...
c++ 二叉搜索树
Hedenghui777的博客
06-22 275
在这里为什么我们需要学习二叉搜索树呢？ map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构。 二叉搜索树的特性了解，有助于更好的理解map和set。 1.二叉搜索树 1.1 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int a [] = {5,3,4,1,7,8,2,6,0,9}; 1.
C++——二叉搜索树
weixin_49449676的博客
11-30 1906
若要删除8，这里采用右树最左节点的替换法，右树的最左节点就是10自己，如果这样写会有错误，while循环都不会进去，minparent就是空，而后面minParent->_left = min->_right;用左子树的最大节1点或右子树的最小节点4，若采用右树的最小节点，交换3和4删除4之后，删除3，但还有一个子节点5，我们让5成为6的左节点。若果要删除跟节点，而且左为空，若要删除8，我们更新根节点即可，让根节点指向10。若果要删除跟节点，而且右为空，若要删除8，让根节点指向3即可。
c++——二叉搜索树
陌上人如玉，公子世无双。
08-17 328
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。 键值对： 用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值， value表示与key对应的信息。 二叉搜索树： 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： ...
C++二叉搜索树——插入
qq_43640822的博客
05-31 479
​ 通过结构体作为节点，结构体包含四个成员，分别是键值key，指向父节点的指针 *parent，指向左子节点的指针 *left，指向右子节点的指针 *right。 struct Node{ int key; Node *left,right,parent; } ​ 从根以起点寻找节点 x 的插入位置。 设当前节点为 x，如果 z 的键值小于 x 则将当前节点的左子节点作为下一个 x，反之则以...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
二叉树-基于C++实现的二叉搜索树.zip
04-26
在C++中实现二叉搜索树，我们需要定义一个节点结构，包含节点的值、左子节点和右子节点的指针。例如： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
二叉搜索树源码分享
09-04
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，其每个节点的值都大于其左子树中所有节点的值，并小于其右...这个实现充分展示了二叉搜索树的基本特性和操作，并利用了C++的模板机制实现泛型编程。
最优二叉搜索树
06-26
最优二叉搜索树，也称为最优化二叉查找树或者动态二叉搜索树，是计算机科学中的一个重要概念，尤其在算法设计与分析领域占据一席之地。这种数据结构主要用于提高查询效率，在某些特定操作序列下，它能比普通二叉搜索...
c++二叉搜索树的创建
11-13
以下是C++中创建二叉搜索树的示例代码： ```c++ #include <iostream> using namespace std; // 定义二叉搜索树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; // 插入节点函数 TreeNode* insertNode(TreeNode* root, int val) { if (root == NULL) { return new TreeNode(val); } if (val < root->val) { root->left = insertNode(root->left, val); } else { root->right = insertNode(root->right, val); } return root; } // 创建二叉搜索树函数 TreeNode* createBST(int arr[], int n) { TreeNode* root = NULL; for (int i = 0; i < n; i++) { root = insertNode(root, arr[i]); } return root; } // 中序遍历函数 void inorderTraversal(TreeNode* root) { if (root == NULL) { return; } inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } int main() { int arr[] = {5, 3, 7, 1, 4, 6, 8}; int n = sizeof(arr) / sizeof(arr[0]); TreeNode* root = createBST(arr, n); inorderTraversal(root); // 输出：1 3 4 5 6 7 8 return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值