Реализовать удаление элемента бинарного дерева

Severity    Code    Description Project File    Line    Suppression State
Error   C2440   '=': cannot convert from 'int' to 'BinaryTree<int>::Elem<T> *'  IAmBinaryMan    c:\users\mazur\documents\visual studio 2015\projects\iambinaryman\iambinaryman\binarytree.h 109 
Error   C2440   '=': cannot convert from 'int' to 'BinaryTree<int>::Elem<T> *'  IAmBinaryMan    c:\users\mazur\documents\visual studio 2015\projects\iambinaryman\iambinaryman\binarytree.h 111 
Error   C2440   '=': cannot convert from 'int' to 'BinaryTree<int>::Elem<T> *'  IAmBinaryMan    c:\users\mazur\documents\visual studio 2015\projects\iambinaryman\iambinaryman\binarytree.h 114 
Error   C2440   '=': cannot convert from 'int' to 'BinaryTree<int>::Elem<T> *'  IAmBinaryMan    c:\users\mazur\documents\visual studio 2015\projects\iambinaryman\iambinaryman\binarytree.h 116

template<class T>
T BinaryTree<T>::RemoveHelper(T value, Elem<T> * bt)
{
    Elem<T> * temp;
    if (bt == NULL)
        return NULL;
    else if (value < bt->value)
        bt->left = RemoveHelper(value, bt->left);
    else if (value > bt->value)
        bt->right = RemoveHelper(value, bt->right);
    else if (bt->left && bt->right)
    {
        temp = GetMinValueFromElem(bt->right);
        bt->value = temp->value;
        bt->right = RemoveHelper(bt->value, bt->right);
    }
    else
    {
        temp = bt;
        if (bt->left == NULL)
            bt = bt->right;
        else if (bt->right == NULL)
            bt = bt->left;
        delete temp;
    }
    return T(); // Пока что заглушка просто
}
template<class T>
void BinaryTree<T>::Remove(T value)
{
    RemoveHelper(value, this->root);
}

#pragma once
#include<iostream>
#include <time.h>
#include <windows.h>
#include "MyException.h"
 
using namespace std;
 
 
template<class T>
class BinaryTree
{
private:
    template<class T>
    struct Elem
    {
        T value;//the meaning stored in the element
        Elem<T> *parent;//the pointer to the parent element
        Elem<T> *left;//the pointer to the left element
        Elem<T> *right;//the pointer to the right element
    };
private:
    Elem<T> *root;//the pointer to the root element 
    int size;//elements quantity of the tree
    void ShowElem(Elem<T> *root);
    void ShowElem(Elem<T> *root, ostream & os);
    void DeleteElem(Elem<T> *root);
    void AddElem(Elem<T> *root);
    T GetMinValueFromElem(Elem<T> *root);//нахождение минимального среди дочерних
public:
    BinaryTree();
    BinaryTree(BinaryTree<T> &bt);
    ~BinaryTree();
    BinaryTree<T> & operator = (BinaryTree<T> &bt);
    bool isEmpty();
    int GetSize();
    T GetMinimum();//возвращает минимальное значение в дереве
                   //T & operator[] (int index);
    void Add(T value);
    T RemoveHelper(T value, Elem<T> *bt);
    void Remove(T value);
    bool Contains(T value);
    void ShowTree();
    template<class T>
    friend ostream & operator << (ostream & os, BinaryTree<T> &bt);
};
 
template<class T>
BinaryTree<T>::BinaryTree()
{
    this->root = NULL;
    this->size = 0;
}
template<class T>
BinaryTree<T>::BinaryTree(BinaryTree<T> &bt)
{
    this->root = NULL;
    this->~BinaryTree();
    this->size = 0;
    if (bt.size == 0)
    {
        return;
    }
    Elem<T> *root = bt.root;
    this->AddElem(bt.root);
}
template<class T>
BinaryTree<T>::~BinaryTree()
{
    this->DeleteElem(this->root);
    this->root = NULL;
    this->size = 0;
    cout << "Destructor\n";
}
template<class T>
BinaryTree<T> & BinaryTree<T>:: operator = (BinaryTree<T> &bt)
{
    if (this == &bt)
    {
        return *this;
    }
    this->DeleteElem(this->root);
    this->root = NULL;
    this->size = 0;
 
    Elem<T> *root = bt.root;
    this->AddElem(bt.root);
    return *this;
}
template<class T>
void BinaryTree<T>::DeleteElem(Elem<T> *root)
{
    if (root == NULL)
    {
        return;
    }
    this->DeleteElem(root->left);
    this->DeleteElem(root->right);
    delete root;
}
 
template<class T>
T BinaryTree<T>::RemoveHelper(T value, Elem<T> * bt)
{
    Elem<T> * temp;
    if (bt == NULL)
        return NULL;
    else if (value < bt->value)
        bt->left = RemoveHelper(value, bt->left);
    else if (value > bt->value)
        bt->right = RemoveHelper(value, bt->right);
    else if (bt->left && bt->right)
    {
        temp = GetMinValueFromElem(bt->right);
        bt->value = temp->value;
        bt->right = RemoveHelper(bt->value, bt->right);
    }
    else
    {
        temp = bt;
        if (bt->left == NULL)
            bt = bt->right;
        else if (bt->right == NULL)
            bt = bt->left;
        delete temp;
    }
    return T(); // Пока что заглушка просто
}
template<class T>
void BinaryTree<T>::Remove(T value)
{
    RemoveHelper(value, this->root);
}
template<class T>
void BinaryTree<T>::AddElem(Elem<T> *root)
{
    if (root == NULL)
    {
        return;
    }
    Add(root->value);
    this->AddElem(root->left);
    this->AddElem(root->right);
}
template<class T>
bool BinaryTree<T>::isEmpty()
{
    return this->root == NULL;
}
template<class T>
int BinaryTree<T>::GetSize()
{
    return this->size;
}
template<class T>
void BinaryTree<T>::Add(T value)
{
    //создание нового элемента
    Elem<T> *n = new Elem<T>;
    //помещаем значение в новый элемент
    n->value = value;
    n->right = NULL;//у последнего элемента всегда next равен NULL
    n->left = NULL;
    n->parent = NULL;
    this->size++;
    if (this->root == NULL)
    {
        this->root = n;
        return;
    }
    Elem<T> *root = this->root;
    Elem<T> *z;
    while (root != NULL)
    {
        z = root;
        if (n->value < root->value)
        {
            root = root->left;
        }
        else
        {
            root = root->right;
        }
    }
    n->parent = z;
    if (n->value < z->value)
    {
        z->left = n;
    }
    else
    {
        z->right = n;
    }
}
 
 
template<class T>
bool BinaryTree<T>::Contains(T value)
{
    //TODO: what is it?
    bool check = false;
    Elem<T> *root = this->root;
    Elem<T> *z;
    while (root != NULL)
    {
        z = root;
        if (value == root->value)
        {
            cout << "The number " << value << " is found\n";
            check = true;
        }
        else if (value < root->value)
        {
            root = root->left;
        }
        else
        {
            root = root->right;
        }
    }
    cout << "The number " << value << " is not found\n";
    return check;
}
template<class T>
T BinaryTree<T>::GetMinimum()
{
    if (this->root == NULL)
    {
        throw MyException("BinaryTree is empty", __FILE__, __func__, __LINE__);
    }
    return this->GetMinValueFromElem(this->root);
}
template<class T>
T BinaryTree<T>::GetMinValueFromElem(Elem<T> *root)
{
    if (root->left == NULL)
    {
        return root->value;
    }
    return this->GetMinValueFromElem(root->left);
}
template<class T>
void BinaryTree<T>::ShowTree()
{
    if (this->root != NULL)
    {
        cout << "Root element : " << this->root->value << endl;
    }
    ShowElem(this->root);
}
 
template<class T>
void BinaryTree<T>::ShowElem(Elem<T> *root)
{
    if (root == NULL)
    {
        return;
    }
    this->ShowElem(root->left);
    cout << root->value << endl;
    this->ShowElem(root->right);
}
template<class T>
void BinaryTree<T>::ShowElem(Elem<T> *root, ostream &os)
{
    if (root == NULL)
    {
        return;
    }
    this->ShowElem(root->left, os);
    os << root->value << endl;
    this->ShowElem(root->right, os);
}
template<class T>
ostream & operator << (ostream & os, BinaryTree<T> &bt)
{
    if (bt.root != NULL)
    {
        os << "Root element : " << bt.root->value << endl;
    }
    bt.ShowElem(bt.root, os);
    return os;
}