Метод удаления двоичного дерева поиска удаляет все узлы, а не только выбранный C++

У меня проблема с отменой узла в моем двоичном дереве поиска. Метод, который я реализовал для исключения узла дерева, вместо этого удаляет все узлы, и я не понимаю, почему. Это класс узла:

#include <iostream>

using namespace std;

template <class T>
class Nodo {
private:
    T val;
    Nodo<T> *sx;
    Nodo<T> *dx;
    Nodo<T> *padre;
public:
    explicit Nodo(T x) {
        this->val = x;
    }
    void setVal(T y) {
        this->val = y;
    }
    T getVal() {return this->val;}

    void setPadre(Nodo<T> *x) {
        this->padre = x;
    }

    Nodo<T> *getPadre() {
        return this->padre;
    }

    void setSx(Nodo<T> *n) {
        this->sx = n;
    }

    void setDx(Nodo<T> *n) {
        this->dx = n;
    }

    Nodo *getSx() {return this->sx;}
    Nodo *getDx() {return this->dx;}
};

Существует класс BST со всеми методами:

template <typename T>
class BinarySearchTree {
private:
    Nodo<T> *radice;
public:
    BinarySearchTree() {
        radice = nullptr;
    }
    void insert(T x) {
        Nodo<T>* tmp = new Nodo<T>(x);
        Nodo<T> *supp = nullptr;
        Nodo<T> *radix = radice;
        tmp->setSx(nullptr);
        tmp->setDx(nullptr);

        while (radix != nullptr) {
            supp = radix;
            if (x < radix->getVal()) {
                radix = radix->getSx();
            } else {
                radix = radix->getDx();
            }
        }
        tmp->setPadre(supp);
        if (supp == nullptr) {
            radice = tmp;
        } else if (x < supp->getVal()) {
            supp->setSx(tmp);
        } else {
            supp->setDx(tmp);
        }
    }

    void _inorder(Nodo<T> *prova) {
        if (prova != nullptr) {
            _inorder(prova->getSx());
            cout << prova->getVal() << " ";
            _inorder(prova->getDx());
        }
    }

    void inorder() {
        _inorder(radice);
        cout << "----" << endl;
    }

    Nodo<T> *minimum(Nodo<T>* x) {
        Nodo<T> *min = x;
        while (min->getSx() != nullptr)
            min = min->getSx();
        return min;
    }

    Nodo<T> *search(T x) {
        Nodo<T> *iter = radice;
        if (x < iter->getVal()) {
            while (iter->getVal() != x)
                iter = iter->getSx();
            return iter;
        } else {
            while (iter->getVal() != x)
                iter = iter->getDx();
            return iter;
        }
    }
    
    void transplant(Nodo<T> *u, Nodo<T> *v) {
        if (u->getPadre() == nullptr) {
            radice = v;
        } else if (u == u->getPadre()->getSx()) {
            u->getPadre()->setSx(v);
        } else {
            u->getPadre()->setDx(v);
        }
        if (v != nullptr)
            v->setPadre(u->getPadre());
    }


    void delTree(T x) {
        Nodo<T> *tmp = search(x);
        Nodo<T> *supp = nullptr;
        if (tmp->getSx() == nullptr)
            transplant(tmp, tmp->getDx());
        else if (tmp->getDx() == nullptr)
            transplant(tmp, tmp->getSx());
        else {
            supp = minimum(tmp->getDx());
            if (supp->getPadre() != tmp) {
                transplant(supp, supp->getDx());
                supp->setDx(tmp->getDx());
                supp->getDx()->setPadre(supp) ;
            }
            transplant(tmp, supp);
            supp->setSx(tmp->getSx());
            supp->getSx()->setPadre(supp);
        }
    }
};


int main() {
    BinarySearchTree<int> bst;
    bst.insert(30);
    bst.insert(10);
    bst.insert(50);
    bst.insert(2);
    bst.inorder();
    bst.delTree(2);
    bst.inorder();
}

Теперь, когда я вызываю метод delTree с любым узлом, он удаляет все узлы. Может ли кто-нибудь помочь мне понять, где ошибка в коде? Спасибо!

Обновлено: я добавил метод search() в класс BST и изменил назначение tmp в методе delTree(), и теперь он работает нормально!