【C++】二叉搜索树

二叉搜索树的定义

对于树中的每个节点Node，它的左子树中所有关键字值小于Node的关键字值，而它的右子树中所有关键字值大于Node的关键字值。根据这个性质，对一个二叉树进行中序遍历，如果是单调递增的，则可以说明这个树是二叉搜索树。

实现一个二叉搜索树

#include <iostream>
using namespace std;
template <class T>
struct BSTNode
{
	BSTNode* _left;
	BSTNode* _right;
	T _value;

	BSTNode(const T& value = T())
		:_left(nullptr),
		_right(nullptr),
		_value(value)
	{}
};

template <class T>
class BSTree
{
public:
	typedef BSTNode Node;
	typedef Node* pNode;
	//查找一个节点
	pNode find(const T& value)
	{
		pNode cur = _root;
		while (cur)
		{
			if (cur->_value == value)
			{
				return cur;
			}
			else if (cur->_value > value)
			{
				cur = cur->_left;
			}
			else
			{
				cur = cur->_right;
			}
		}
		//出循环则找不到该value
		return cur;
	}
	//插入一个节点
	bool insert(const T& value)
	{
		//处理空树
		if (_root == nullptr)
		{
			_root = new Node(value);
			return true;
		}
		pNode cur = _root;
		//保存cur的父亲节点
		pNode parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (cur->_value == value)
			{
				return false;
			}
			else if (cur->_value > value)
			{
				cur = cur->_left;
			}
			else
			{
				cur = cur->_right;
			}
		}
		cur = new Node(value);
		//判断cur的位置
		if (parent->_value > value)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}
	//删除一个节点
	bool erase(const T& value)
	{
		if (cur == nullptr)
		{
			return false;
		}
		pNode cur = _root;
		pNode parent = nullptr;
		while (cur)
		{
			if (cur->_value == value)
			{
				break;
			}
			else if (cur->_value > value)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				parent = cur;
				cur = cur->_right;
			}
		}
		//判断是否有节点存在
		if (cur == nullptr)
		{
			return false;
		}
		//若该节点没有左子树
		//该种情况包括了叶子结点
		if (cur->_left == nullptr)
		{
			if (cur != _root)
			{
				if (parent->_value > cur->_value)
				{
					parent->_left = cur->_right;
				}
				else
				{
					parent->_right = cur->_right;
				}
			}
			else
				_root = cur->_right;
			delete cur;
			cur = nullptr;
		}
		//若该节点没有右子树
		else if (cur->_right == nullptr)
		{
			if (cur != _root) 
			{
				if (parent->_value > cur->_value)
				{
					parent->_left = cur->_left;
				}
				else
				{
					parent->_right = cur->_left;
				}
			}
			else
				_root = cur->_left;
			delete cur;
			cur = nullptr;
		} 
		//若该节点有左右子树
		//则找到左子树的最优节点
		//或是右子树最左节点
		//与该节点交换value，
		//再做删除操作
		else
		{
			pNode pNext = cur->_right;
			pNode parent = nullptr;
			while (pNext->_left)
			{
				parent = pNext;
				pNext = pNext->_left;
			}
			cur->_value = pNext->_value;
			if (parent->_left == pNext)
			{
				parent->_left = pNext->_right;
			}
			else
			{
				parent->_right = pNext->_right;
			}
			delete pNext;
			pNext = nullptr;
		}

	}

	void _inOrder(pNode root)
	{
		if (root)
		{
			_inOrder(root->_left);
			cout << root->_value << endl;
			_inOrder(root->_right);
		}
	}

	void inOrder()
	{
		_inOrder();
		cout << endl;
	}

private:
	pNode _root = nullptr;
};