C++-二叉搜索树

最新推荐文章于 2025-09-26 08:00:00 发布
原创 最新推荐文章于 2025-09-26 08:00:00 发布 · 713 阅读 · 41 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

1.二叉搜索树概念

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

        2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

        3、它的左右子树也分别为二叉搜索树

2.二叉搜索树操作

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

上述数组按照二叉树的形式为：

1. 二叉搜索树的查找

        a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。

        b、最多查找高度次，走到到空，还没找到，这个值不存在。

2. 二叉搜索树的插入 插入的具体过程如下：

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

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

1.二叉树的删除

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

a. 要删除的结点无孩子结点

b. 要删除的结点只有左孩子结点

c. 要删除的结点只有右孩子结点

d. 要删除的结点有左、右孩子结点

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

情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除

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

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

3.二叉搜索树的实现

K模型：

namespace key
{
	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()
			:_root(nullptr)
		{}

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

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

		~BSTree()
		{
			Destroy(_root);
		}

		bool Insert(const K& key)	//非递归插入
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			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
				{
					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	//找到目标值
				{
					//左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_right == cur)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
						}
					}
					//右为空
					else if (cur->_right = nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_right == cur)
							{
								parent->_right = cur->_left;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}
					}
					//左右都不为空
					else
					{
						parent = cur;	//找替代节点
						Node* leftMax = cur->_left;
						while (leftMax->_right)
						{
							parent = leftMax;
							leftMax = leftMax->_right;
						}

						swap(cur->_key, leftMax->_key);

						if (parent->_left == leftMax)
						{
							parent->_left = leftMax->_left;
						}
						else
						{
							parent->_right = leftMax->_left;
						}

						cur = leftMax;
					}

					delete cur;
					return true;
				}
			}
			return false;
		}

		void InOrder()	//中序遍历
		{
			_InOrder(_root);
			cout << endl;
		}

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

	private:
		Node* Copy(Node* root)	//深拷贝复制二叉树
		{
			if (root == nullptr)
				return nullptr;
			Node* copyroot = new Node(root->_key);
			copyroot->_left = Copy(root->_left);
			copyroot->_right = Copy(root->_right);
			return copyroot;
		}

		void Destroy(Node*& root)	//递归释放二叉树内存
		{
			if (root == nullptr)
				return;
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
			root = nullptr;
		}

		//递归删除二叉搜索树中键值为 key 的节点。
		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;
				//1、左为空
				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				//2、右为空
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				//3、左右都不为空
				else
				{
					Node* leftMax = root->_left;
					while (leftMax->_right)
					{
						leftMax = leftMax->_right;
					}
					swap(root->_key, leftMax->_key);
					return _EraseR(root->_left, key);
				}

				delete del;
				return true;
			}
		}

		//递归插入键值 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;
		}

		//递归检查键值 key 是否存在。
		bool _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}

			if (root->_key < key)
			{
				return _Find(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _FindR(root->_left, key);
			}
			else return true;
		}

		//中序遍历打印二叉搜索树。
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}

	private:
		Node* _root;
	};

	void TestBSTree1()
	{
		int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
		BSTree<int> t;
		for (auto e : a)
		{
			t.InsertR(e);
		}

		t.InOrder();

		t.Erase(4);
		t.InOrder();

		t.EraseR(6);
		t.InOrder();

		t.EraseR(7);
		t.InOrder();

		t.EraseR(3);
		t.InOrder();

		for (auto e : a)
		{
			t.EraseR(e);
		}
		t.InOrder();
	}

	void TestBSTree2()
	{
		int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
		BSTree<int> t;
		for (auto e : a)
		{
			t.InsertR(e);
		}

		BSTree<int> t1(t);

		t.InOrder();
		t1.InOrder();
	}
}

KV模型：

namespace key_value
{
	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)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _value(value)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		BSTree()
			:_root(nullptr)
		{}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

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

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

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

	private:
		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;

				// 1、左为空
				// 2、右为空
				// 3、左右都不为空
				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					Node* leftMax = root->_left;
					while (leftMax->_right)
					{
						leftMax = leftMax->_right;
					}

					swap(root->_key, leftMax->_key);

					return _EraseR(root->_left, key);
				}

				delete del;
				return true;
			}
		}

		bool _InsertR(Node*& root, const K& key, const V& value)
		{
			if (root == nullptr)
			{
				root = new Node(key, value);
				return true;
			}

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

		Node* _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
				return nullptr;

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

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

			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root;
	};

	void TestBSTree1()
	{
		BSTree<string, string> dict;
		dict.InsertR("insert", "插入");
		dict.InsertR("sort", "排序");
		dict.InsertR("right", "右边");
		dict.InsertR("date", "日期");

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

	void TestBSTree2()
	{
		// 统计水果出现的次数
		string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
		BSTree<string, int> countTree;
		for (auto& str : arr)
		{
			auto ret = countTree.FindR(str);
			if (ret == nullptr)
			{
				countTree.InsertR(str, 1);
			}
			else
			{
				ret->_value++;
			}
		}

		countTree.InOrder();
	}
}

4.二叉搜索树的应用

1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到 的值。

比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

        以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树

        在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

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

        比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对；

        再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出 现次数就是就构成一种键值对

5.二叉搜索树的性能分析

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

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

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

        最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为:O(log2_N) 

        最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：O(N)

        问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？

解决方案

  • AVL树：通过严格的平衡条件（任意节点的左右子树高度差不超过1），在插入或删除时通过旋转操作维护平衡，确保树的高度始终为 $O(\log N)$。

  • 红黑树：通过一组特定的规则（如节点颜色、黑高度平衡等）来近似平衡树，虽然平衡条件不如AVL树严格，但能保证树的高度为 $O(\log N)$，且在插入和删除时需要的调整操作较少，效率更高。

【C++】二叉树
AliceK1008的博客
07-04 612
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。二叉树可以为空树，通常子树被称为”左子树“和”右子树“ 比如下图就是一棵二叉树 二叉树的每个节点最多有两棵子树（不存在度大于2的节点），二叉树的子树有左右之分，次序不能颠倒 二叉树的第i层，最多有2i−12^{i-1}2i−1个结点 深度为k的二叉树，最多有2k−12^k-12k−1个结点 对于任何一颗二叉树，如果其叶结点数为n0n0n0，度为2的节点数为n2n2n2，则n0=n2+1n0=n2+1n0=n2+1 对于最后一个结论可以这么理解，当我们
C++树（四）二叉树
weixin_70468627的博客
07-25 2482
二叉搜索树（ Binary Search Tree ）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；能够快速查找数据也是二叉搜索树被用于各类数据结构的原因，但这种快速是有限制的，即不会出现退化，假如二叉搜索树退化为链表，则无法做到快速查找数据的要求，所以又出现了平衡二叉树。遍历二叉树的方法可以沿用遍历树的方法——递归。
【C++】数据结构——二叉搜索树（详细图解，详细代码实现）
最新发布
tangsl1552的博客
09-26 2252
本文介绍了C++中的二叉搜索树(BST)数据结构。首先讲解了二叉搜索树的基本概念和特性：左子树值小于根节点，右子树值大于根节点。随后详细分析了二叉搜索树的实现方式，包括节点类设计、构造函数、拷贝构造函数和析构函数等核心组件。文章还重点讲解了BST的关键操作：插入、查找和删除的算法实现，并区分了key-only和key/value两种使用场景。最后提供了完整的key/value二叉搜索树实现代码，展示了如何应用于实际场景如字典查询和单词统计。文章内容全面，从理论到实践系统地介绍了二叉搜索树的实现与应用。
C++数据结构---二叉树
Rookie_Ws的博客
04-22 3598
树 树的概念 树是一种能分层存储数据的数据结构，树中的每个元素被称为树的节点，每个节点有若干个指针指向子节点 从节点的角度来看，树是由唯一的起始结点引出的节点集合，这个起始结点被称为根(root)， 树中节点的子树数目称为节点的度 树的度指其中节点的度最大值。比如1号节点的孩子是2、3、4，则1号节点的度数是3，且1号节点的度是最大的，故该树的度为3。 二叉树 二叉树是指对于树中的每个节点而言，最多由两个子节点，即任意节点的度小于等于2 层数：从根节点到某个节点的路径长度，根节点为0层 高度：最大层数+
二叉树搜索
weixin_34122810的博客
07-07 193
删除数值一般来说，须要依据以下几种情况分别进行处理： 1.须要删除的节点没有左儿子，那么把右儿子提上去 2.须要删除的节点的左儿子没有右儿子，那么就把左儿子提上去 3.以上两种情况都不满足的话，就把左儿子的子孙中最大的节点提到须要删除的节点上 和堆一样。非常多情况下不须要自己实现二叉搜索树，使用C++中的STL，STL里有set和map容器， set是使用erc搜索树维护集合的容器，而...
搜索二叉树
宇哲
10-21 1891
二叉搜索树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树有个特点，最左的是最小的节点，最右的是最大的节点。 当我们把二叉搜索树进行中序遍历的时候，它是进行排序后的结果，所以我们也把二叉搜索树叫做排序二叉树。接下来我们介绍二叉
【C++】二叉搜索树
春风不语。
10-01 1508
本篇到这里就结束了，主要讲了二叉搜索树的基本概念以及实现逻辑，希望对大家有所帮助，祝生活愉快，我们下篇再见！
【二叉树进阶】--- 二叉搜索树转双向链表 && 最近公共祖先
2301_79448270的博客
08-14 2055
不同的是，我们需要记录前驱节点prev，ptail->next = node,此时的node就是我们中序遍历的当前访问节点，此时ptail需要更新成node(当前访问节点),prev就是上一个按中序被访问节点，所以我们需要在更新ptail之前记录prev，同时更新好前驱和后继指针的指向。归根结底，找公共祖先也就是找公共节点，如果我们能求出两个节点的祖先路径，就能转化为链表相交问题了。题目要求链表中的节点是排好序的，因此结合二叉搜索树的性质(二叉搜索树中序遍历出来是有序的)，我们可以。
C++编程-二叉搜索树的插入
weixin_43979090的博客
04-27 367
题目： 给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。 示例 1： 输入：root = [4,2,7,1,3], val = 5 输出：[4,2,7,1,3,5] 解释：另一个满足题目要求可以通过的树是： 示例 2： 输入：root = [40,20,60,10
【C++】-二叉搜索树的详解（递归和非递归版本以及巧用引用）
qq_69369227的博客
08-01 884
这篇博客赶紧来学学，让你可以更好进入学习AVL树和红黑树
eagleeye05#cpp-note#33-二叉搜索树的后序遍历序列1
07-25
假设输入的数组的任意两个数字都互不相同扩展：判断数组是不是某BST的前序遍历结果使用递归，利用后序遍历的性质bool dfs(int left, int rig
c++二叉树
weixin_34050005的博客
10-17 131
1 #ifndef _TREE_H_ 2 #define _TREE_H_ 3 //此类用shared_ptr来管理节点内存，所以要包含<memory>头文件,不需要手动释放内存 4 #include <memory> 5 #include <iostream> 6 7 using namespace std; 8 ...
C++二叉树
weixin_33861800的博客
07-09 176
自学数据结构不久，看着课本上的意思自己写的一些二叉树基本操作，还有很多不足，希望看到的大神给些意见。 #include <iostream> #include <cstdio> #include <stack> #include <queue> using namespace std; struct tree { i...
二叉查找树（二叉排序树）操作大全C++实现
pleasetojava
11-01 315
// 链式二叉查找树的各种操作.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; using namespace std; struct BSTree { int data; BSTree *left; BSTre...
查找二叉树（BST）
WHTGS的博客
03-04 363
今天分享一些关于BST的内容： 一、基础知识点 1 一棵树最上面的节点称为根节点，如果一个节点下面连接多个节点，那么该节点称为父节点，，，它下面的节点称为子节点。一个节点可以有0个 1个 或多个子节点，没有任何子节点的节点称为叶子节点 2 以某种特定的顺序访问树中所有的节点称为树的遍历 3 树可以分为几个层次，根节点是第0层，子节点是第1层，子节点的子节点是第2层，依次类推 二、今天的主角...
查找二叉树（树）
chrisblogtk的博客
04-08 1824
Description 已知一棵二叉树用邻接表结构存储，中序查找二叉树中值为x的结点，并指出是第几个结点 Input 第一行为二叉树的结点个数，n Output 输出一个数即查找的结点编号 Sample Input   7 15  5 2 3  12 4 5  10 0 0  29 0 0  15 6 7  8 0 0  23 0 0   Samp
查找二叉树
Genius_panda_ACM的博客
08-10 720
题目描述 已知一棵二叉树用邻接表结构存储，中序查找二叉树中值为x的结点，并指出是 第几个结点。 输入        第一行n为二叉树的结点个树，n&lt;=100；第二行x表示要查找的结点的值；以下第一列数据是各结点的值，第二列数据是左儿子结点编号，第三列数据是右儿子结点编号。 输出 输出要查找的结点数目。 样例输入 7 15 5 2 3 12 4 5 10 0 0 29 0...
评论 14
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值