搜索二叉树的简单实现

实现二叉树的插入，查找，删除，以及递归实现：

插入和查找很简单，把握一点，小的在树左，大的在树右，大树子树都遵循一样的规则，查找就更简单了：

主要看删除，删除有三种情况，看图：

在一下代码中详细有说明：

#pragma once

template<class K,class V>
struct SBTNode
{
	K key;
	V value;

	SBTNode<K, V> *_left;
	SBTNode<K, V> *_right;

	SBTNode(const K& key, const V& value)
		:key(key)
		, value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}

};

template<class K, class V>
class SBTree
{
	typedef SBTNode<K, V> Node;
public:
	SBTree()
		:_root(nullptr)
	{}

	~SBTree()
	{}

public:
	//非递归插入
	bool Insert(const K& key,const V& value)
	{
		return _Insert(key,value);
	}

	bool _Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new SBTNode<K, V>(key, value);
			return true;
		}

		SBTNode<K, V> *parent = nullptr; //指向cur 的前驱
		SBTNode<K, V> *cur = _root;
		while (cur)
		{
			if (cur->key > key)  //插左边
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		if (parent->key < key)
		{
			SBTNode<K, V> *node = new SBTNode<K, V>(key, value);
			parent->_right = node;
			return true;
		}

		else if (parent->key > key)
		{
			SBTNode<K, V> *node = new SBTNode<K, V>(key, value);
			parent->_left = node;
			return true;
		}
		else
		{
			return false;
		}
	}

	//递归插入
	bool Insert_R(const K& key, const V& value)
	{
		return _Insert_R(_root,key,value);
	}

	bool _Insert_R(Node* root, const K& key, const V& value)
	{
		if (root == nullptr)
		{
			root = new Node(key, value);
			return true;
		}

		if (root->key > key)
		{
			return _Insert_R(root->_left, key, value);
		}
		else if (root->key < key)
		{
			return _Insert_R(root->_right,key,value);
		}
		else
		{
			cout << key << "存在" << endl;
			return false;
		}
	}

	//非递归查找节点
	SBTNode<K, V>* Find(const K& key)
	{
		if (_root == nullptr)
		{
			return nullptr;
		}

		SBTNode<K, V> *cur = _root;
		while (cur)
		{
			if (cur->key == key)
			{
				return cur;
			}
			else if (cur->key > key)
			{
				cur = cur->_left;
			}
			else if (cur->key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return nullptr;
			}
		}
		return nullptr;
	}

	
	SBTNode<K, V>* Find_R(const K& key)
	{
		return _Find_R(_root,key);
	}

	//递归查找
	Node* _Find_R(Node* root, const K& key)
	{
		if (root == nullptr)
		{
			return nullptr;
		}

		Node* cur = root;
		if (cur->key == key)
		{
			return cur;
		}

		else if (cur->key > key)
		{
			_Find_R(cur->_left,key);
		}
		else if (cur->key < key)
		{
			_Find_R(cur->_right,key);
		}
		else
		{
			return nullptr;
		}
	}

	//非递归删除节点
	bool Remove(const K& key)
	{
		//1.root为空
		if (_root == nullptr)
		{
			return false;
		}

		else if (_root->_left == nullptr && _root->_right == nullptr)
		{
			delete _root;
			_root = nullptr;
			return true;
		}

		Node* parent = nullptr;
		Node* del = _root;
		
		//1.查找要删的数
		while (del)
		{
			if (del->key > key)
			{
				parent = del;
				del = del->_left;
			}
			else if (del->key < key)
			{
				parent = del;
				del = del->_right;
			}
			else
			{
				//2.是没有此数，或者找到此数
				break;
			}
		}

		//3.处理被删节点
		if (del)
		{
			//1.左树为空，右子树替换
			if (del->_left == nullptr)
			{
				if (del == _root)
				{
					_root = del->_right;
				}
				else
				{
					if (del == parent->_left)
						parent->_right = del->_right;
					else
						parent->_left = del->_right;
				}
			}

			//2.右树为空，左子树替换
			else if (del->_right == nullptr)
			{
				if (del == _root)
				{
					_root = del->_left;
				}
				else
				{
					if (del == parent->_left)
						parent->_left = del->_left;
					else
						parent->_right = del->_left;
				}
			}

			//3.左右子树都不为空的情况
			else
			{
				Node* subRight = del->_right;
				Node* firstInder = del->_right;
				//找右边节点中序遍历的第一个节点
				while (firstInder->_left)
				{
					parent = firstInder;
					firstInder = firstInder->_left;
				}

				//交换
				swap(firstInder->key,del->key);
				swap(firstInder->value,del->value);

				if (firstInder = parent->_left)
					parent->_left = firstInder->_right;
				else
					parent->_right = firstInder->_right;

				del = firstInder;
			}
			delete del;
		}
		else
		{
			cout << "没有这个数" << endl;
			return false;
		}
	}

	//递归删除节点
	bool Remove_R(const K& key)
	{
		return _Remove_R(_root,key);
	}

	bool _Remove_R(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->key > key)
		{
			return _Remove_R(root->_left,key);
		}
		else if (root->key < key)
		{
			return _Remove_R(root->_right,key);
		}
		else
		{
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
				delete del;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
				delete del;
			}
			else
			{
				Node* firstInder = root->_right;
				while (firstInder->_left)
				{
					firstInder = firstInder->_left;
				}

				swap(del->key,firstInder->key);
				swap(del->value, firstInder->value);

				_Remove_R(firstInder,key);
			}
		}
	}

	//中序遍历
	void InOrder(SBTNode<K, V>* root)
	{
		if (root == nullptr)
		{
			return; //递归结束出口
		}

		SBTNode<K, V> *cur = root;
		InOrder(cur->_left);
		cout << cur->key << " ";
		InOrder(cur->_right);
	}


public:
	SBTNode<K, V> *_root;
};


void Test()
{
	int a[] = {5,3,4,1,7,8,2,6,0,9};
	SBTree<int, int> s1;
	for (int i = 0; i < sizeof(a)/sizeof(int); ++i)
	{
		s1.Insert(a[i],a[i]);
	}
	s1.InOrder(s1._root);
	cout << endl;
	cout << s1.Find(9)->key << endl;
	cout << s1.Find_R(0)->key<< endl;

	s1.Remove(5);
	s1.Remove_R(9);
	s1.InOrder(s1._root);
}

代码测试通过，赐教！