[C++系列] 76. 详解BST二叉搜索树

1. 二叉搜索树的概念

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

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

2. 二叉搜索树的操作

2.1 二叉搜索树的查找

2.2 二叉搜索树的插入

1. 树为空，则直接插入
   
2. 树不空，按二叉搜索树性质查找插入位置，插入新节点
   

2.3 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

1. 要删除的结点无孩子结点
2. 要删除的结点只有左孩子结点
3. 要删除的结点只有右孩子结点
4. 要删除的结点有左、右孩子结点

看起来有待删除节点有 4 中情况，实际情况 a 可以与情况 b 或者 c 合并起来，因此真正的删除过程有三种情况：

1. 删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点
2. 删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点
3. 在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题

3. 二叉搜索树的实现

#include <iostream> 

using namespace std;

template<class T>
struct BSTNode
{
	BSTNode(const T& val = T())
		:_left(nullptr)
		, _right(nullptr)
		, _data(val)
	{}
	BSTNode<T>* _left;
	BSTNode<T>* _right;
	T _data;
};

template<class T>
class BSTree {
	typedef BSTNode<T> Node;

public:
	BSTree()
		: _pRoot(nullptr)
	{}

	Node* Copy(Node* root) {
		if (root) {
			Node* newNode = new Node(root->_data);
			newNode->_left = Copy(root->_left);
			newNode->_right = Copy(root->_right);
			return newNode;
		}
		else return nullptr;
	}

	BSTree(const BSTree<T>& bst) {
		_pRoot = Copy(bst._pRoot);
	}

	BSTree<T>& operator=(const BSTree<T>& bst) {
		if (this != &bst) {
			if (_pRoot) {
				Destory(_pRoot);
			}
			_pRoot = Copy(bst._pRoot);
		}
		return *this;
	}

	void Destory(Node* root) {
		if (root) {
			Destory(root->_left);
			Destory(root->_right);
			delete root;
			root = nullptr;
		}
	}

	~BSTree() {
		if (_pRoot)
			Destory(_pRoot);
	}

	Node* find(const T& x) {
		if (_pRoot == nullptr) return nullptr;
		Node* cur = _pRoot;
		while (cur) {
			if (cur->_data == x) 
				return cur;
			else if (x > cur->_data) 
				cur = cur->_right;
			else 
				cur = cur->_left;
		}
		return nullptr;
	}

	bool Insert(const T& x) {
		if (_pRoot == nullptr) {
			_pRoot = new Node(x);
			return true;
		}

		Node* cur = _pRoot;
		Node* parent = nullptr;
		while (cur) {
			if (cur->_data == x) return false;
			else if (x > cur->_data) {
				parent = cur;
				cur = cur->_right;
			}
			else {
				parent = cur;
				cur = cur->_left;
			}
		}
		cur = new Node(x);
		if (parent->_data > x) parent->_left = cur;
		else parent->_right = cur;
		return true;
	}

	bool Erase(const T& x) {
		if (_pRoot == nullptr) return false;
		Node* cur = _pRoot;
		Node* parent = nullptr;
		// 1. 查找 x 元素
		while (cur) {
			if (cur->_data == x) break;
			else if (cur->_data > x) {
				parent = cur;
				cur = cur->_left;
			}
			else {
				parent = cur;
				cur = cur->_right;
			}
		}

		// x 不在 BST 中，无法删除
		if (cur == nullptr) return false;

		// 1. 叶子节点
		if (cur->_left == nullptr && cur->_right == nullptr) {
			if (cur != _pRoot) {
				if (parent->_left == cur) parent->_left = nullptr;
				else parent->_right = nullptr;
			}
			else _pRoot = nullptr;

			delete cur;
			cur = nullptr;
		}

		// 2. 孩子节点不完整
		else if (cur->_left == nullptr) {
			if (cur != _pRoot) {
				if (parent->_left == cur) parent->_left = cur->_right;
				else parent->_right = cur->_right;
			}
			else {
				_pRoot = cur->_right;
			}
			delete cur;
			cur = nullptr;
		}

		else if (cur->_right == nullptr) {
			if (cur != _pRoot) {
				if (parent->_right == cur) parent->_right = cur->_left;
				else parent->_left = cur->_left;
			}
			else {
				_pRoot = cur->_left;
			}
			delete cur;
			cur = nullptr;
		}

		// 3. 孩子节点完整
		else {
			Node* leftMost = cur->_left;
			parent = cur;
			// 找到左边最大
			while (leftMost->_right) {
				parent = leftMost;
				leftMost = leftMost->_right;
			}
			// 置换
			cur->_data = leftMost->_data;
			if (parent->_right == leftMost) parent->_right = leftMost->_left;
			else parent->_left = leftMost->_left;
			// 删除节点
			delete leftMost;
			leftMost = nullptr;
		}
		return true;
	}

	void Inorder() {
		_Inorder(_pRoot);
		cout << endl;
	}

	void _Inorder(Node* root) {
		if (root)
		{
			_Inorder(root->_left);
			cout << root->_data << " ";
			_Inorder(root->_right);
		}
	}

private:
	Node* _pRoot;
};

int main() {
	BSTree<int> bstree;
	bstree.Insert(10);
	bstree.Insert(9);
	bstree.Insert(4);
	bstree.Insert(8);
	bstree.Insert(2);
	bstree.Insert(19);
	bstree.Insert(31);

	bstree.Inorder();

	BSTree<int> copy(bstree);
	copy.Inorder();
	copy.Erase(10);
	copy.Inorder();
	copy = bstree;
	copy.Inorder();

	system("pause");
	return 0;
}

4. 二叉搜索树性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：$lo{g}_{2}N$
最差情况下，二叉搜索树退化为单支树，其平均比较次数为：$N/2$

5. 一个小问题

如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，都可以是二叉搜索树的性能最佳？

答：AVL树，见下篇blog。