二叉搜索树

#include<iostream>
#include<queue>
using namespace std;
template<class T>
struct BinaryTreeNode
{
    BinaryTreeNode* left;
    BinaryTreeNode* right;
    T element;
    BinaryTreeNode(T ele) :element(ele), left(nullptr), right(nullptr) {}
};
template<class T>
class BinarySearchTree
{
public:
    BinarySearchTree();
    BinarySearchTree(const BinarySearchTree<T>& btree);
    void LevelTraversal();
    BinaryTreeNode<T>* Find(const T& ele) const;
    void Insert(const T& ele);
    void Delete(const T& ele);
    BinaryTreeNode<T>* GetParent(const BinaryTreeNode<T>* node,bool& left) const;
    BinaryTreeNode<T>* GetRoot() const
    {
        return root;
    }
private:
    BinaryTreeNode<T>* root;
    BinaryTreeNode<T>* CopyTreeNode(const BinaryTreeNode<T>* node);
    void TransParent(BinaryTreeNode<T>* u, BinaryTreeNode<T>* v);
    BinaryTreeNode<T>* TreeMinimum( BinaryTreeNode<T>* node) const;
    BinaryTreeNode<T>* TreeMaximum(BinaryTreeNode<T>* node) const;

};
template<class T>
BinarySearchTree<T>::BinarySearchTree()
{
    root = nullptr;
}
template<class T>
BinarySearchTree<T>::BinarySearchTree(const BinarySearchTree<T>& btree)
{
    if (btree.root == nullptr)
    {
        root = nullptr;
        return;
    }
    root = new BinaryTreeNode<T>(btree.root->element);
    root->left = CopyTreeNode(btree.root->left);
    root->right = CopyTreeNode(btree.root->right);
}
template<class T>
BinaryTreeNode<T>* BinarySearchTree<T>::CopyTreeNode(const BinaryTreeNode<T>* node)
{
    if (node == nullptr)
    {
        return nullptr;
    }
    BinaryTreeNode<T>* t_node = new BinaryTreeNode<T>(node->element);
    t_node->left = CopyTreeNode(node->left);
    t_node->right = CopyTreeNode(node->right);
    return t_node;
}
template<class T>
BinaryTreeNode<T>* BinarySearchTree<T>::Find(const T& ele) const
{
    BinaryTreeNode<T>* node = root;
    while (node != nullptr)
    {
        if (node->element == ele)
        {
            return node;
        }
        else if (node->element > ele)
        {
            node = node->left;
        }
        else
        {
            node = node->right;
        }
    }
    return nullptr;
}

template<class T>
BinaryTreeNode<T>* BinarySearchTree<T>::GetParent(const BinaryTreeNode<T>* node,bool& left) const
{
    BinaryTreeNode<T>* temp = root;
    BinaryTreeNode<T>* parent = root;
    if (node == root)
    {
        return nullptr;
    }
    while (temp != node)
    {
        parent = temp;
        if(temp->element > node->element)
        {
            temp = temp->left;

        }
        else
        {
            temp = temp->right;

        }
    }
    if (parent->left == node)
    {
        left = true;
    }
    else if (parent->right == node)
    {
        left = false;
    }
    return parent;
}

template <class T>
BinaryTreeNode<T>* BinarySearchTree<T>::TreeMinimum(BinaryTreeNode<T>* node) const
{
    BinaryTreeNode<T>* temp = node;
    while (temp->left != nullptr)
    {
        temp = temp->left;
    }
    return temp;
}
template<class T>
BinaryTreeNode<T>* BinarySearchTree<T>::TreeMaximum(BinaryTreeNode<T>* node) const
{
    BinaryTreeNode<T>* temp = node;
    while (node->right != nullptr)
    {
        node = node->right;
    }
    return temp;
}
template<class T>
void BinarySearchTree<T>::LevelTraversal()
{
    queue<BinaryTreeNode<T>*> que;
    que.push(root);
    int cur_level_size = 1;
    int next_level_size = 0;
    while (!que.empty())
    {
        BinaryTreeNode<T>* cur = que.front();
        cout << cur->element << "  ";
        que.pop();
        cur_level_size--;
        if (cur->left != nullptr)
        {
            que.push(cur->left);
            next_level_size++;
        }
        if (cur->right != nullptr)
        {
            que.push(cur->right);
            next_level_size++;
        }
        if (cur_level_size == 0)
        {
            cur_level_size = next_level_size;
            next_level_size = 0;
            cout << endl;
        }
    }
}
template< class T>
void BinarySearchTree<T>::Insert(const T& ele)
{
    BinaryTreeNode<T>* node = root;
    BinaryTreeNode<T>* parent = root;
    if (root == nullptr)
    {
        root = new BinaryTreeNode<T>(ele);
        return;
    }
    while (node != nullptr)
    {
        parent = node;
        if (node->element > ele)
        {           
            node = node->left;
        }
        else
        {
            node = node->right;
        }
    }
    node = new BinaryTreeNode<T>(ele);
    if (ele < parent->element)
    {
        parent->left = node;
    }
    else
    {
        parent->right = node;
    }

}
template<class T>
void BinarySearchTree<T>::TransParent(BinaryTreeNode<T>* u, BinaryTreeNode<T>* v)
{
    if (u == root)
    {
        v = root;
        return;
    }
    bool left;
    BinaryTreeNode<T>* parent = GetParent(u, left);
    if (left)
    {
        parent->left = v;
    }
    else
    {
        parent->right = v;
    }
}
template<class T>
void BinarySearchTree<T>::Delete(const T& ele)
{
    bool node_left;
    BinaryTreeNode<T>* node = Find(ele);
    BinaryTreeNode<T>* parent = GetParent(node,node_left);
    cout << node->element << endl;
    cout << parent->element << endl;
    if (node->right == nullptr)
    {
        TransParent(node, node->left);
    }
    else if (node->left == nullptr)
    {
        TransParent(node, node->right);
    }
    else
    {
        bool replace_left;
        BinaryTreeNode<T>* replace = TreeMinimum(node->right);
        cout << replace->element << endl;
        BinaryTreeNode<T>* replace_parent =GetParent(replace,replace_left);
        cout << replace_parent->element << endl;
        if (replace_parent != node)
        {
            TransParent(replace, replace->right);
            replace->right = node->right;

        }
        replace->left = node->left;

        if (node_left)
        {
            parent->left = replace;
        }
        else
        {
            parent->right = replace;
        }
    }   
}
int main()
{
    BinarySearchTree<int> btree;
    btree.Insert(5);
    for (int i = 0; i < 5; i++)
    {
        btree.Insert(i);
    }
    for (int i = 6; i < 10; i++)
    {
        btree.Insert(i);
    }
    btree.Delete(7);
    btree.LevelTraversal();
    btree.Insert(7);
    btree.LevelTraversal();
    btree.Delete(9);
    btree.Insert(10);
    btree.LevelTraversal();
    btree.Insert(9);
    btree.Insert(11);
    btree.LevelTraversal();
    btree.Delete(10);
    btree.LevelTraversal();
    return 0;
}