二叉搜索树

一、定义

所谓的二叉搜索树，其实就是具有以下特定性质的二叉树：

1）每个节点都有一个关键码（key），关键码可以作为搜索依据，且所有节点的关键码都不能相同。

2）左子树上所有节点的关键码都小于根节点的关键码。

3）右子树上所有节点的关键码都大于根节点的关键码。

4）根节点的左右子树也都是二叉搜索树。

二、删除操作

二叉搜索树的删除有三种情况，一种是待删除节点没有孩子，一种是待删除节点只有左孩子或只有右孩子，一种是待删除节点既有左孩子又有右孩子。事实上，第一种情况可以概括到第二种情况中一并处理。

删除方法可见下图：

二、 代码

#pragma once
template<class K,class V>
struct BSTreeNode
{
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;
	K _key;
	V _value;
	BSTreeNode(const K& key, const V& value)
		:_key(key)
		, _value(value)
		, _left(NULL)
		, _right(NULL)
	{}
};

template<class K,class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
public:
	BSTree()
		:_root(NULL)
	{}
	
	bool Insert(const K& key, const V& value)
	{
		if (_root == NULL)
		{
			_root = new Node(key, value);
			return true;
		}
		Node* parent = NULL;
		Node* cur = _root;
		while (cur)   //直到cur为空（因为cur已经给了parent，所以这里的意思是直到parent为叶子节点）
		{
			if (cur->_key < key)  //插入的数较大
			{
				parent = cur;    
				cur = cur->_right;   //cur向右走
			}
			else if (cur->_key>key)   //插入的数较小 
			{
				parent = cur;
				cur = cur->_left;    //cur向左走
			}
			else
			{
				return false;
			}
		}
		if (key > parent->_key)  //在parent的左右插入新节点
		{
			parent->_right = new Node(key, value);
		}
		else
		{
			parent->_left = new Node(key, value);
		}
		return true;
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;   //返回指针
			}
		}
		return NULL;  //找不到时
	}

	bool Remove(const K& key)
	{
		Node* parent = NULL;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key>key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				break;
			}
		}
		if (cur == NULL)
		{
			return false;
		}
		Node* del;
		if (cur->_left == NULL)   //待删除节点的左孩子为空
		{
			del = cur;
			if (parent == NULL)
			{
				_root = cur->_right;
			}
			else
			{
				if (parent->_left == cur)
				{
					parent->_left = cur->_right;
				}
				else
				{
					parent->_right = cur->_right;
				}
			}
		}
		else if (cur->_right == NULL)  //待删除节点的右孩子为空
		{
			del = cur;
			if (parent == NULL)
			{
				_root = cur->_left;
			}
			else
			{
				if (parent->_left == cur)
				{
					parent->_left = cur->_left;
				}
				else
				{
					parent->_right = cur->_left;
				}
			}
		}
		else    //待删节点的左右孩子都存在
		{
			parent = cur;
			Node* firstLeft = cur->_right;
			while (firstLeft->_left)
			{
				parent = firstLeft;   //parent记录firstLeft的父亲
				firstLeft = firstLeft->_left;
			}
			del = firstLeft;   //记录下交换后要删除的节点
			cur->_key = firstLeft->_key;   //交换两节点的值
			cur->_value = firstLeft->_value;
			if (parent->_left == firstLeft) //最左节点是父亲节点的左孩子时
			{
				parent->_left = firstLeft->_right;
			}
			else  //最左节点也有可能是父亲节点的右孩子，此时最左节点的父亲就是待删除节点
			{
				parent->_right = firstLeft->_right;
			}
		}
		delete del;
		return true;	
	}

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


protected:
	void _InOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

	Node* _root;
};

void TestTree()
{
	int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
	BSTree<int, int> t;
	for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		t.Insert(a[i], i);
	}
	t.InOrder();

	BSTreeNode<int, int>* ret = t.Find(7);
	cout << ret->_key << ":" << ret->_value << endl;

	t.Remove(7);
	t.Remove(5);
	//t.Remove(0);
	//t.Remove(1);
	//t.Remove(2);
	//t.Remove(3);
	//t.Remove(4);
	//t.Remove(6);
	//t.Remove(8);
	//t.Remove(9);
	//t.Remove(9);
	t.InOrder();
}