二叉搜索树(BST)的具体实现


1. BST树概念

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

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

在这里插入图片描述

对一颗二叉搜索树进行中序遍历,就可以按照从小到大的顺序,将各节点关键码排列起来,所以被称为二叉排序树。

BST的结构如下:


template<typename T>
class bstTree;

template<typename T>
class bstNode
{
	friend bstTree<T>;
    public:
    	explicit bstNode():left_(nullptr),right_(nullptr)
    	{}

        bstNode(T data) : data_(data),left_(nullptr),right_(nullptr)
    	{}
    	
        ~bstNode() {}

    private:
        T val_;
        bstNode* left_;
        bstNode* right_;
};

template<typename T>
class bstTree
{
    public:
        bstTree() : root_(nullptr)
        {}
        bstTree(vector<T> iv) : root_(nullptr)
        {
            for(const auto &e : iv)
                _Insert(root_,e);
        }
        ~bstTree() {}
        T& Max() const
        {
            return _Max(root_);
        }
        T& Min() const
        {
            return _Min(root_);
        }
        bstTree<T>* Search(const T& val) const
        {
            return _Search(root_,val);
        }
        bool Insert(const T& val)
        {
            return _Insert(root_,val);
        }
        bool Remove(const T& val)
        {
            return _Remove(root_,val);
        }
        
    protected:
        bool _Remove(bstTree<T>*& pos,const T& value);
        bool _Insert(bstNode<T>*& pos,const T& value);
        bstTree<T>* _Search(bstTree<T>*& pos,const T& value);
        T& _Min(bstNode<T>* pos);
        T& _Max(bstNode<T>* pos);

        
    private: 
        bstNode<T>* root_; 
};

2. BST接口的实现

2.1 寻找BST树中的结点(Search)

bstTree<T>* _Search(bstTree<T>*& pos,const T& value);

代码实现:

template<typename T>
bstTree<T>* bstTree<T>::_Search(bstTree<T>*& pos,const T& value)
{
	assert(pos != nullptr);

	if(val == pos->val_)
		return pos;
	else if(pos->val_> val)
		return Search(pos->left_,value);
	else
		return Search(pos->right_,value);
}

2.2 BST树中最大结点和最小结点

T& _Max(bstNode<T>* pos);

T& _Min(bstNode<T>* pos);

代码如下:

template<typename T>
T bstTree<T>::Max()
{
	assert(root_);
	bstNode<T>* cur = root_;
	while (cur->right_)
		cur = cur->right_;

	return cur->val_;
}

template<typename T>
T bstTree<T>::Min()
{
	assert(root_);
	bstNode<T>* cur = root_;
	while (cur->left_)
		cur = cur->left_;

	return cur->val_;
}

2.3 BST树的插入方法

bool _Insert(bstNode<T>*& pos,const T& value);

递归实现

template<typename T>
bool bstTree<T>::_Insert(bstNode<T>*& pos, const T& value)
{
	if (pos == nullptr)
	{
		pos = new bstNode<T>(value);
		return true;
	}

	if (pos->data_ > pos)
		_Insert(pos->left_, value);
	else if (pos->data_ < pos)
		_Insert(pos->right_, value);

	return false;
}

非递归实现

template<typename T>
bool bstTree<T>::_Insert(bstNode<T>*& pos, const T& value)
{
	bstNode<T>* cur = pos;
	bstNode<T>* parent = nullptr;

	while (cur)
	{
		parent = cur;
		if (cur->val_ == value)
			return false;
		if (cur->val_ < value)
			cur = cur->right_;
		else
			cur = cur->left_;
	}

	cur = new bstNode<T>(value);
	if (parent == nullptr)
		pos = cur;
	else
	{
		if (parent->val_ > value)
			parent->left_ = cur;
		else
			parent->right_ = cur;
	}

	return true;

}

2.4 BST树的删除方法

bool _Remove(bstTree<T>*& pos,const T& value);

递归实现

template<typename T>
bool bstTree<T>::_Remove(bstTree<T>*& pos,const T& value)
{
	if (pos == nullptr)
		return false;
	else if (pos->val_ < value)
		return _Remove(pos->right_, value);
	else if (pos->data_ > value)
		return _Remove(pos->left_, value);
	else
	{
		if (pos->left_ && pos->right_)
		{
			auto tmp = pos->left_;
			while (tmp->right_ != nullptr)
				tmp = tmp->right_;
			pos->val_ = tmp->val_;
			_Remove(pos->left_, pos->val_);
		}
		else
		{
			auto tmp = pos;
			if (pos->left_ != nullptr)
				pos = pos->left_;
			else
				pos = pos->right_;

			delete tmp;
			return true;
		}
	}
}

非递归实现

template<typename T>
bool bstTree<T>::_Remove(bstTree<T>*& pos,const T& value)
{
	if (pos == nullptr)
		return false;
	bstNode<T>* cur = pos;
	bstNode<T>* parent = nullptr;
	while (cur != nullptr && cur->val_ != value)
	{
		parent = cur;
		if (cur->val_ > value)
			cur = cur->left_;
		else
			cur = cur->right_;
	}

	if (cur == nullptr)
		return false;

	bstNode<T>* tmp;

	if (cur->left_ && cur->right_)
	{
		parent = cur;

		tmp = cur->left_;

		while (tmp->right_)
		{
			parent = tmp;
			tmp = tmp->right_;
		}

		cur->val_ = tmp->val_;

		cur = tmp;
	}

	if (cur->left_ == nullptr && cur->right_ == nullptr)
	{
		if (parent->val_ > cur->val_)
			parent->left_ = nullptr;
		else
			parent->right_ = nullptr;
		delete cur;
		return true;
	}

	if (cur->left_ != nullptr)
		tmp = cur->left_;
	else
		tmp = cur->right_;

	if (parent == nullptr)
	{
		delete pos;
		pos = nullptr;
		return true;
	}

	if (parent->val_ > tmp->val_)
		parent->left_ = tmp;
	else
		parent->right_ = tmp;

	delete cur;
	return true;
}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值