二叉搜索树

最新推荐文章于 2024-07-17 20:58:24 发布

原创最新推荐文章于 2024-07-17 20:58:24 发布 · 370 阅读

0 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

12 篇文章

订阅专栏

本文详细介绍了二叉搜索树的概念，包括其结构定义、性能分析及实现方式。探讨了节点插入、查找和删除操作，并提供了代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是二叉搜索树？

二叉搜索树又叫二叉排序树，空树是特殊的二叉搜索树。若左子树不为空，那么左子树节点上的值都小于根节点的值；若右子树不为空，那么右子树上所有节点的值都大于根节点的值；左右子树也是二叉搜索树。

二叉搜索树的性能分析

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树。

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log2N

最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2

二叉搜索树节点的结构定义

template <class T>
struct BSTreeNodePlus {
	BSTreeNodePlus<T>* _left;
	BSTreeNodePlus<T>* _right;
	T _data;

	BSTreeNodePlus(const T& data = T())
		:_data(data)
		,_left(nullptr)
		,_right(nullptr)
	{ }
};

二叉搜索树的实现

template <class T>
class BSTreePlus {
	typedef BSTreeNodePlus<T> Node;
public:
	BSTreePlus()
		:_root(nullptr)
	{}
	//插入一个节点
	bool Insert(const T& x)
	{
		//判断树是否为空
		if (_root == nullptr) {
			_root = new Node(x);
			return true;
		}
		//树不为空，要找合适的位置插入,从根节点开始匹配
		Node* cur = _root;
		//要记录每一步走的前一个位置
		Node* parent = nullptr;
		while (cur) {
			parent = cur;
			if (cur->_data > x) {
				cur = cur->_left;
			}
			else if (cur->_data < x) {
				cur = cur->_right;
			}
			else {
				return false;
			}
		}
		cur = new Node(x);
		//插入元素
		if (parent->_data < x)
			parent->_right = cur;
		else
			parent->_left = cur;
		return true;
	}
	bool Find(const T& x)
	{
		if (_root == nullptr)
			return false;
		Node* cur = _root;
		while (cur) {
			if (cur->_data > x)
				cur = cur->_left;
			else if (cur->_data < x)
				cur = cur->_right;
			else {
				return true;
			}
		}
		return false;
	}
	//删除一个节点 分两步 
	//第一步 ：找到这个节点的位置
	//第二步：删除  删除又分为三种情况 
	bool Erase(const T& x)
	{
		//如果为空树，直接返回
		if (_root == nullptr)
			return false;
		//首先找到要删除的节点
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur) {

			if (cur->_data > x) {
				parent = cur;
				cur = cur->_left;
			}

			else if (cur->_data < x) {
				parent = cur;
				cur = cur->_right;
			}
			else {
				//找到了
				//执行第二步：判断是那种情况
				//左子树为空的情况
				if (cur->_left == nullptr) {
					if (parent == nullptr) {

						_root = cur->_right;
					}
					else {
						if (cur == parent->_right)
							parent->_right = cur->_right;
						else
							parent->_right = cur->_right;
					}

				}
				//右子树为空的情况
				else if (cur->_right = nullptr) {
					if (parent == nullptr) {
						_root = cur->_left;
					}
					else {
						if (cur == parent->_left)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
				}
				//左右子树都不为空
				//不能直接删除，找一个节点替代它，左子树最大，右子树最小
				else {
                                        //两种做法：找右子树的最小节点
					//Node* del = nullptr;
					//Node* reParent = cur;
					//Node* replace = cur->_right;
					//while (replace->_left) {
					//	reParent = replace;
					//	replace = replace->_left;
					//}
					////找到右子树最小的元素
					////将这个元素直接赋值给要删除的元素
					//cur->_data = replace->_data;
					//del = replace;
					//if (reParent->_left == replace)
					//	reParent->_left = replace->_right;
					//else
					//	reParent->_right = replace->_right;
                                        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                        //找左子树的最大节点
					Node* del = nullptr;
					Node* reParent = cur;
					Node* replace = cur->_left;
					while (replace->_right) {
						reParent = replace;
						replace = replace->_right;
					}
					cur->_data = replace->_data;
					del = replace;
					if (replace == reParent->_right)
						reParent->_right = replace->_left;
					else
						reParent->_left = replace->_left;
				}
				break;
			}
			
		}
		return false;
	}
	//递归调用，提供接口
	void InOrder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root) {
			_InOrder(root->_left);
			cout << root->_data << " ";
			_InOrder(root->_right);
		}
	}

private:
	Node* _root;
};

另一种写法：插入pair<K, V>，原理和上面一样

#pragma once
#include <iostream>
using namespace std;

template <class K, class V>
struct BSTreeNode {
	pair<K, V>_kv;
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

	BSTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

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

	BSTree()
		:_root(nullptr)
	{}
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr) {
			_root = new Node(kv);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur) {
			parent = cur;
			if (cur->_kv.first < kv.first) {
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first) {
				cur = cur->_left;
			}
			else {
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
			parent->_right = cur;
		else
			parent->_left = cur;

		return true;
	}
	bool find(const K& key)
	{
		if (_root == nullptr) {
			return false;
		 }
		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first > key)
				cur = cur->_left;
			else if (cur->_kv.first < key)
				cur = cur->_right;
			else
				return  true;
		}
		return  false;
	}
	bool Earse(const K& key)
	{
		if (_root == nullptr)
			return false;
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur) {
			if (cur->_kv.first > key){
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < key) {
				parent = cur;
				cur = cur->_right;
			}
			else {
				Node* del = cur;
				if (cur->_left = nullptr) {
					if (parent == nullptr) {
						_root = cur->_right;
					}
					else {
						if (cur == parent->_left)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}

				}
				else if (cur->_right == nullptr) {
					if (parent == nullptr) {
						_root = cur->_left;
					}
					else {
						if (cur == parent->_left)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}

				}
				//左右子树都不为空的情况
				else {
					Node* rParent = cur;
					Node* replace = cur->_right;
					//找右子树中最小的节点
					while (replace->_left) {
						rParent = replace;
						replace = replace->_left;
					}
					//把代替节点赋值给要（原）删除的节点
					cur->_kv = replace->_kv;
					del = replace;
					if (rParent->_left == del)
						rParent->_left = del->_right;
					else
						rParent->_right = del->_right;
				}
				break;
			}


		}
		return false;
	}
	void InOrder()
	{
		_InOrder(_root);
	}

	void _InOrder(Node* root)
	{
		if (root)
		{
			_InOrder(root->_left);
			cout << root->_kv.first << " ";
			_InOrder(root->_right);
		}
	}
private:
	Node* _root;
};