二叉搜索树的实现(数据结构)

原创 已于 2022-07-25 12:48:37 修改 · 320 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c++

于 2022-07-25 12:35:46 首次发布
本文主要复习了二叉搜索树的基本操作，包括插入、查找和删除节点。详细介绍了不同情况下的删除策略，如节点无子节点、只有一个子节点或有两个子节点时的处理。还提供了后序遍历销毁树的实现。通过K模型和KV模型展示了模板类的定义，并给出了测试代码以验证功能的正确性。

                    

        前一段时间一直在学习Linux网络知识，同时准备项目。今天抽出时间就把曾经学过的二叉搜索树这个数据结构拿出来复习一下~

目录

二叉搜索树结点(K模型)

struct BSTreeNode

成员变量定义

成员函数

BSTree()

~BSTree()

void Destroy(Node* root)

bool Insert(const K& key)

bool Find(const K& key)

bool Erase(const K& key)

bool EraseR(const K& key)

Node* FindR(const K& key)

void InOrder()

bool InsertR(const K& key)

K模型完整代码

KV模型完整代码

测试代码

二叉搜索树结点(K模型)

struct BSTreeNode

//key
template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

 //key
template<class K> //这里实现K模型版本，所以这里先只定义一个模板K
struct BSTreeNode
{
    BSTreeNode<K>* _left;  //该结点的指向左结点的指针
    BSTreeNode<K>* _right; //该节点指向右节点的指针
    K _key; //结点中存储的_key值
    BSTreeNode(const K& key) //构造函数
        :_left(nullptr)
        , _right(nullptr)
        , _key(key)
    {}
};

成员变量定义

	typedef BSTreeNode<K> Node;
private:
	Node* _root;

成员函数

BSTree()

BSTree()
	:_root(nullptr)
{}

BSTree() //构造函数对指针_root初始化
    :_root(nullptr) //注意，结点_root在这里没有调用BSTreeNode构造函数
{}

~BSTree()

~BSTree()
{
	Destroy(_root);
}

~BSTree() //析构函数，销毁在堆上给结点开辟的空间
{
    Destroy(_root); //调用Destroy函数递归释放空间
}

void Destroy(Node* root)

void Destroy(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	//后序遍历递归销毁树
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

bool Insert(const K& key)

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 //有相同的key时,就不插入数据了
		{
			return false;
		}
	}
	cur = new Node(key);
	//重新判断插入方向
	if (parent->_key < key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	return true;
}

bool Find(const K& key)

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)

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) //cur的 左为空右为空/左为空右不为空
			{
				if (parent == nullptr)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else //(parent->_right == cur)
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
				if (parent == nullptr)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else //(parent->_left == cur)
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			else //cur->left != nullptr && cur->_right != nullptr
			{
				//找cur右子树的最左节点
				Node* min = cur->_right;
				Node* minParent = cur;//这里给nullptr会出问题
				while (min->_left)
				{
					minParent = min;
					min = min->_left;
				}
				cur->_key = min->_key;//相当于找个结点来替代
				if (minParent->_left == min)
				{
					minParent->_left = min->_right;
				}
				else
				{
					minParent->_right = min->_right;
				}
				delete min;
			}
			return true;
		}
	}
	return false; //没有找到,cur为空了
}

bool EraseR(const K& key)

bool EraseR(const K& key)
{
	return _EraseR(_root, 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; //记录要删除的结点
		if (root->_left == nullptr) //root是上一个root->_left/root->_right的别名
		{
			root = root->_right;
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;
		}
		else  //删除的结点左右都不为空时
		{
			Node* min = root->_right;
			while (min->_left) //找右子树的最左节点
			{
				min = min->_left;
			}
			swap(min->_key, root->_key);

			//递归到右子树去删除，实际上还是走了上面的条件
			//return是递归结束的一个标志
			return _EraseR(root->_right, key); //这个地方不return的话下面的delete会走多次！
		}
		delete del; //走单边树的删除
		return true;
	}
}

Node* FindR(const K& key)

Node* FindR(const K& key) //这里不能直接用_root,在外面穿不进来根节点
{
	return _FindR(_root, key);
}
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()

void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->_left); //左子树
	cout << root->_key << " "; //根
	_InOrder(root->_right); //右子树
}

bool InsertR(const K& key)

bool InsertR(const K& key)
{
	return _InsertR(_root, 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;
	}
}

K模型完整代码

namespace K
{
//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()
	{
		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 //有相同的key时,就不插入数据了
			{
				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) //cur的 左为空右为空/左为空右不为空
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else //(parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else //(parent->_left == cur)
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else //cur->left != nullptr && cur->_right != nullptr
				{
					//找cur右子树的最左节点
					Node* min = cur->_right;
					Node* minParent = cur;//这里给nullptr会出问题
					while (min->_left)
					{
						minParent = min;
						min = min->_left;
					}
					cur->_key = min->_key;//相当于找个结点来替代
					if (minParent->_left == min)
					{
						minParent->_left = min->_right;
					}
					else
					{
						minParent->_right = min->_right;
					}
					delete min;
				}
				return true;
			}
		}
		return false; //没有找到,cur为空了
	}

	Node* FindR(const K& key) //这里不能直接用_root,在外面穿不进来根节点
	{
		return _FindR(_root, key);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
private:
	void Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		//后序遍历递归销毁树
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}
	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->_left/root->_right的别名
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else  //删除的结点左右都不为空时
			{
				Node* min = root->_right;
				while (min->_left) //找右子树的最左节点
				{
					min = min->_left;
				}
				swap(min->_key, root->_key);

				//递归到右子树去删除，实际上还是走了上面的条件
				//return是递归结束的一个标志
				return _EraseR(root->_right, key); //这个地方不return的话下面的delete会走多次！
			}
			delete del; //走单边树的删除
			return true;
		}
	}
	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;
		}
	}
	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 == nullptr)
		{
			return;
		}
		_InOrder(root->_left); //左子树
		cout << root->_key << " "; //根
		_InOrder(root->_right); //右子树
	}
	private:
		Node* _root;
	};
}

KV模型完整代码

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

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		BSTree()
			:_root(nullptr)
		{}
		~BSTree()
		{
			Destroy(_root);
		}
		bool Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else //又该key的结点，就不插入了
				{
					return false;
				}
			}
			//找到了地方，开始插入
			cur = new Node(key, value);
			if (parent->_key > key)
			{
				parent->_left = cur;
			}
			else
			{
				parent->_right = cur;
			}
			return true;
		}
		Node* Find(const K& key)
		{
			Node* cur = _root;//用临时变量记录_root，直接用_root迭代的话，_root就被改变了
			while (cur)
			{
				if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else
				{
					return cur;
				}
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else //找到了，准备删除
				{
					if (cur->_left = nullptr)
					{
						if (parent == nullptr) //cur为根节点时
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else //parent->_right == cur
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
						cur = nullptr;
					}
					else if (cur->_right == nullptr)
					{
						if (parent == nullptr) //cur为根节点时
						{
							_root = _root->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else //parent->_right == cur
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
						cur = nullptr;
					}
					else //要删除的结点左右子节点都不为空时
					{
						Node* minParent = cur;
						Node* min = cur->_right;
						while (min->_left)
						{
							minParent = min;
							min = min->_left;
						}
						cur->_key = min->_key;
						cur->_value = min->_value;

						if (minParent->_left == min)
						{
							minParent->_left = min->_right;
						}
						else //minParent->_right == min --->当cur右子树是单树(且全为右子树)的特殊情况
						{
							minParent->_right = min->_right;
						}
						delete min;
						min = nullptr;
					}
					return true;
				}
			}
			return false;//没有找到
		}
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void Destroy(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			//后序遍历递归销毁树
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
		}
		void _InOrder(Node* cur)
		{
			if (cur == nullptr) //递归一定要有结束条件
			{
				return;
			}
			_InOrder(cur->_left);
			cout << cur->_key << " : " << cur->_value << endl;
			_InOrder(cur->_right);
		}
	private:
		Node* _root;
	};
}

测试代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include"BSTree.h"
using namespace std;


void test_BSTree_K()
{
	K::BSTree<int> b;
	int arr[] = { 5,3,4,1,7,8,2,6,0,9,5,5 };
	for (auto e : arr)
	{
		b.Insert(e);
	}

	b.InOrder();

	b.Erase(7);
	b.InOrder();

	b.Erase(5);
	b.InOrder();

	b.Erase(0);
	b.InOrder();

	b.Erase(1);
	b.InOrder();

	for (auto e : arr)
	{
		b.EraseR(e);
		b.InOrder();
	}
	b.InOrder();
}
void test_BSTree_KV1()
{
	//字典KV模型
	KV::BSTree<string, string> dict;
	dict.Insert("sort", "排序");
	dict.Insert("left", "左边、剩余");
	dict.Insert("right", "右边、正确");
	dict.Insert("search", "搜索");
	string str;
	while (cin >> str)
	{
		if (str == "-1")
		{
			break;
		}
		KV::BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret)
		{
			cout << "对应的中文翻译：" << ret->_value << endl;
		}
		else
		{
			cout << "没有找到" << endl;
		}
	}
}
void test_BSTree_KV2()
{
	//统计水果出现的次数
	string arr[] = { "苹果","香蕉","苹果","梨" ,"草莓","西瓜" ,"苹果","草莓" ,"梨","梨" ,"西瓜","香蕉" ,"苹果","西瓜" };
	KV::BSTree<string, int> countTree;
	//KV::BSTreeNode<string, int> countTree("wmm",1); //调用根节点的构造函数，需要传参
	for (const auto& e : arr)
	{
		KV::BSTreeNode<string, int>* ret = countTree.Find(e);
		if (ret == nullptr)
		{
			countTree.Insert(e, 1); //没有则插入
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.InOrder();
}
int main()
{
	//test_BSTree_K();
	test_BSTree_KV2();
	//test_BSTree_KV1();
	return 0;
}

测试结果：

数据结构——二叉查找树的详细实现(c++)
lining0420的博客
07-27 1万+
本文实现了二叉查找树的前序遍历（递归与非递归）、中序遍历（递归与非递归）、后序遍历（递归与非递归）、插入过程、删除过程、查找过程等。
【数据结构】二叉搜索树（Java + 链表实现）
明志の博客
08-07 1860
Map接口是独立的实现Iterable接口的集合都是可以使用 for - Each 语句进行打印的搜索性能会非常高。
二叉搜索树 的实现
qq_55164622的博客
09-23 383
什么是二叉搜索树？二叉搜索树有什么特性？二叉搜索树是怎样实现的？ （1）二叉搜索树 又称二叉查找树、二叉排序树，顾名思义二叉搜索树的查找效率非常的高，而且二叉搜索树要满足二叉树的结构特性故每个根节点最多只有两个叶子节点。这的二叉搜索树和前面学的堆的结构也是相似的。 ...
二叉搜索树的实现
qq_62905847的博客
11-08 671
java详细实现二叉搜索树
BST.rar_bst_二叉搜索树_数据结构动画_树 动画
09-23
二叉搜索树（BST，Binary Search Tree），是数据结构中一种非常重要的树形数据结构，它的每个节点都包含一个键、一个关联值、一个指向左子节点的引用和一个指向右子节点的引用。在二叉搜索树中，对于任何有效的节点...
数据结构课设二叉搜索树算法应用与实现
11-26
二叉搜索树具有如下性质 结点的左子树只包含小于当前结点的数，结点的右子树只包含大于当前结点的数，所有左子树和右子树自身必须也是二叉搜索树。 遍历二叉树；在访问其左子树和右子树时，我们也按照同样的方式遍历...
javascript数据结构之二叉搜索树实现方法
11-24
总结来说，二叉搜索树是一种强大的数据结构，它利用特定的结构特性实现了高效的搜索和排序。通过JavaScript实现的二叉搜索树类，我们可以方便地进行节点插入、查找和遍历操作，这在处理大量有序数据时非常有用。
【计算机科学】基于数据结构的高效算法设计：二叉搜索树在有序数据管理中的应用与实现
最新发布
10-05
并通过二叉搜索树的Python实现，详细分析了插入、查找、删除等操作的原理与复杂度，展示了数据结构在实际编码中的应用逻辑；最后展望了数据结构在智能化、自适应以及与前沿技术融合的发展方向。; 适合人群：具备...
【二叉搜索树】二叉搜索树的实现
菜鸟成长记
08-16 1155
定义二叉搜索树：又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树1、若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 3、它的左右子树也分别为二叉搜索树如图所示，就是一个二叉搜索树，其实二叉搜索树就是在二叉树的基础上加了上面三条特性。结论：可以看出将二叉排序树 进行中序遍历就是 递增的序列节点设计 所以节点设
数据结构-二叉搜索树的实现
weixin_34077371的博客
10-27 184
定义 二叉搜索树(Binary Search Tree,BST),也称为二叉排序树或二叉查找树。 相较于普通的二叉树，非空的二叉搜索树有如下性质： 非空左子树的所有键值小于其根结点的键值； 非空右子树的所有键值大于其根结点的键值； 左右子树均为二叉搜索树； 树中没有键值相等的结点。 可以看到，二叉搜索树的性质很鲜明，这也使得二叉树也有了实际意义。 二叉搜索树的常用操作 对于二叉搜索树，除了常规...
二叉搜索树实现
lw18781108072的博客
12-29 301
二叉搜索树的实现是用树的结果来实现的 搜索二叉树的构成原理： 递归找到要插入的位置，然后创建节点返回的时候把节点连接起来， 二叉搜索树就是左边的都比跟节点小，右边的都比根节点大，和折半查找差不多 首先介绍二叉搜索的insert操作，就是构成二叉搜索树 public Node _insert(Node node,int key,int value) { if(node ==null...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值