二叉搜索树(C++)

一、二叉搜索树的概念

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

1. 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
2. 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
3. 它的左右子树也分别为二叉搜索树

所以二叉搜索树经过中序遍历之后会变得升序有序。

二、二叉树的操作及实现思路

 

//以这个数组来进行二叉搜索树的测试

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

1. 二叉搜索树的查找

实现查找的思路： 

        a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
        b、最多查找高度次，走到到空，还没找到，这个值不存在,就返回false。 

2. 二叉搜索树的插入

实现插入的具体过程如下：
           a. 树为空，则直接新增节点，赋值给root指针
           b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

3.二叉搜索树的删除（难点）

 实现思路：

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
况：
        a. 要删除的结点无孩子结点
        b. 要删除的结点只有左孩子结点
        c. 要删除的结点只有右孩子结点
        d. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下：
        情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除
        情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除
        情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点
中，再来处理该结点的删除问题--替换法删除

三、二叉搜索树的实现代码

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:
	//插入功能
	bool Insert(const K& key)//默认定义：搜索数不能冗余。
	{
        //一开始根节点无数据，第一个插入的就是根节点
		if (nullptr == _root)
		{
			_root = new Node(key);
			return true;
		}
        
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key > key)//插入的值比根小，往左边插入
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)//插入的值比根大，往右边插入
			{
				parent = cur;
				cur = cur->_right;
			}
			else//有相同的数，不插入，不能冗余
			{
				return false;
			}		
		}
        //经过上面循环以后key值到达插入的位置节点
		cur = new Node(key);
        //判断是要插入parent节点的左边还是右边
		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* cur = _root;
		Node* parent = nullptr;//便于连接数
		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 (cur == _root)
					{
						_root = cur->_right;
					}
					else//删除的不是根节点
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr)//要删除的节点右边为空
				{
                    //如果是要删除最顶上的根节点，它的右边没有数，它的左边就是新的根节点
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else //左右都不为空，用替换法
				{
					Node* rightminparent = cur;
                    //这里是找删除节点的右子树的最左节点（值）替换
					Node* rightmin = cur->_right;
					while (rightmin->_left)//找rightmin
					{
						rightminparent = rightmin;
						rightmin = rightmin->_left;
					}
					swap(rightmin->_key, cur->_key);//替换
                    //rightmin是右子树的最左节点，它的下面要是还有节点的话，也就只有右边会有
					if(rightminparent->_left == rightmin)
						rightminparent->_left = rightmin->_right;
					else
						rightminparent->_right = rightmin->_right;

					delete rightmin;
				}
				return true;
			}
		}
		return false;
	}

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

private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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