[C++ ]二叉搜索树（BSTree）的模拟实现

#pragma once

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)
		:_left(nullptr)
		, _right(nullptr)
		, _kv(kv)
	{}
};

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* parent = nullptr;
		Node* cur = _root;
		while (cur){
			if (cur->_kv.first > kv.first){
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first){
				parent = cur;
				cur = cur->_right;
			}
			else{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first < kv.first){
			parent->_right = cur;
		}
		else{
			parent->_left = cur;
		}
		return true;
	}

	Node* Find(const K& key){
		Node* cur = _root;
		while (cur){
			if (cur->_kv.first < key){
				cur = cur->_right;
			}
			else if (cur->_kv.first > key){
				cur = cur->_left;
			}
			else{
				return cur;
			}
		}
		return nullptr;
	}

	bool Remove(const K& key){
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur){
			if (cur->_kv.first < key){
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > key){
				parent = cur;
				cur = cur->_left;
			}
			else{
				// 1.只有0-1个孩纸
				// 2.有两个孩纸
				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* rpParent = cur;
					Node* replace = cur->_right;
					while (replace->_left){
						rpParent = replace;
						replace = replace->_left;
					}

					cur->_kv = replace->_kv;
					del = replace;
					if (rpParent->_left == replace){
						rpParent->_left = replace->_right;
					}
					else{
						rpParent->_right = replace->_right;
					}
				}
				delete del;
				return true;
			}
		}
		return false;
	}

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

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

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

private:
	Node* _root;
};

测试代码

void TestBSTree1(){
	BSTree<int, int> tree;
	tree.Insert(make_pair(1, 1));
	tree.Insert(make_pair(3, 1));
	tree.Insert(make_pair(4, 1));
	tree.Insert(make_pair(6, 1));
	tree.Insert(make_pair(1, 1));
	tree.Insert(make_pair(2, 1));
	tree.InOrder();

	tree.Remove(1);
	tree.Remove(3);
	tree.Remove(2);
	tree.Remove(6);
	tree.Remove(4);
	tree.Remove(1);
	tree.Remove(10);
	tree.InOrder();
}

输出结果：