二叉搜索树

#include<iostream>
using namespace std;
template<class K,class V>
struct BSTNode
{
    K _key;
    V _value;
    BSTNode<K, V> *_left;
    BSTNode<K, V> *_right;
    BSTNode(const K&key,const V&value)
        :_key(key), _value(value), _left(NULL), _right(NULL)
    {}
};

template<class K, class V>
class BSTree
{
    typedef BSTNode<K, V>  Node;
protected:
    Node* _root;
public:
    BSTree() :_root(NULL)
    {}
    ~BSTree()
    {}
    void Inorder()
    {
        return _Inorder(_root);
        cout << endl;
    }
    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)
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;
            }

            if (parent->_key < key)
            {
                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 Insert_R(const K&key, const V&value)
    {
        return _Insert_R(_root, key, value);
    }

    Node* Find_R(const K&key)
    {
        return _Find_R(_root, key);
    }

    bool Remove_R(const K&key)
    {
        return _Remove_R(_root, key);
    }

    bool Remove(const K&key)//非递归删除
    {
        return _Remove(_root, key);
    }

protected:
    bool _Insert_R(Node*&root, const K&key, const V&value)
    {
        if (root == NULL)
        {
            root = new Node(key, value);
            return true;
        }
        if (root->_key < key)
        {
            return _Insert_R(root->_right, key, value);
        }
        if (root->_key > key)
        {
            return _Insert_R(root->_left, key, value);
        }
        else
        {
            return false;
        }
    }

    Node* _Find_R(Node*&root, const K&key)
    {
        if (root == NULL)
        {
            return NULL;
        }
        if (root->_key < key)
        {
            return _Find_R(root->_right, key);
        }
        else if (root->_key>key)
        {
            return _Find_R(root->_left, key);
        }
        else
        {
            return root;
        }
    }

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

    bool _Remove(Node*& root, const K&key) //非递归删除
    {
        if (root == NULL)
        {
            return false;
        }
        if (root->_left == NULL&&root->_right == NULL)
        {
            delete root;
            root = NULL;
            return true;
        }
        Node* parent = NULL;
        Node* del = root;
        while (del)
        {
            if (del->_key < key)
            {
                parent = del;
                del = del->_right;
            }
            else if (del->_key > key)
            {
                parent = del;
                del = del->_left;
            }
            else
            {
                break;
            }
        }
        if (del)
        {
            if (del->_left == NULL)
            {
                if (del == root)
                {
                    root = del->_right;
                }
                else
                {
                    if (del == parent->_left)
                    {
                        parent->_left = del->_right;
                    }
                    else
                    {
                        parent->_right = del->_right;
                    }
                }
            }
            else if (del->_right == NULL)
            {
                if (del == root)
                {
                    root = del->_left;
                }
                else
                {
                    if (del == parent->_left)
                    {
                        parent->_left = del->_left;
                    }
                    else
                    {
                        parent->_right = del->_left;
                    }
                }
            }
            else
            {
                Node* parent = del;
                Node* firstInorder = del->_right;
                while (firstInorder->_left)
                {
                    parent = firstInorder;
                    firstInorder = firstInorder->_left;
                }
                swap(del->_key, firstInorder->_key);
                swap(del->_value, firstInorder->_value);
                if (firstInorder == parent->_left)
                {
                    parent->_left = firstInorder->_right;
                }
                else
                {
                    parent->_right = firstInorder->_right;
                }
                delete del;
                del = NULL;
                return true;
            }
        }
    }

    void _Inorder(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        else
        {
            _Inorder(root->_left);
            cout << root->_key << " ";
            _Inorder(root->_right);
        }
    }
};
void Test()
{
    int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
    BSTree<int, double> t;
    for (size_t i = 0; i < sizeof(a) / sizeof(int);++i)
    {
        t.Insert_R(a[i], a[i]);
    }
    t.Inorder();
    cout << endl;
    cout<<t.Find(4);
    cout << endl;
    //t.Remove(4);
    t.Remove(2);
    /*t.Remove_R(1);
    t.Remove_R(5);*/

    t.Inorder();
    cout << endl;
}