二叉搜索树递归析构函数

Question

我检查了其他类似的主题，但似乎没有一个对我有帮助。

我正在尝试为此特定的BST实现编写析构函数。 每个节点都包含一个指向父节点的指针，一个指向左节点的指针，一个指向右节点的指针以及一个指向它包含的值的指针。 这是班级开始的样子：

#ifndef BST_H
#define BST_H

#include <iostream>

template <typename T>
class BST{
    private:
        BST<T> *left;
        BST<T> *right;
        BST<T> *parent;
        T *value;

    public:
        BST() {
            this->parent = NULL;
            this->left = NULL;
            this->right = NULL;
            this->value = NULL;
        }

        ~BST() {
            removeRecursively(this);
        }

        void removeRecursively(BST<T>* node) {
            if (node->left != NULL)
                removeRecursively(node->left);
            if (node->right != NULL)
                removeRecursively(node->right);
            if (node->left == NULL && node->right == NULL) {
                if (node->parent->left == node)
                    node->parent->left = NULL;
                if (node->parent->right == node)
                    node->parent->right = NULL;

                node->parent = NULL;
                node->value = NULL;
                delete node->value;
                delete node;
            }
        }

        void add(T value) {
            if (this->value == NULL) { // root-only case
                this->value = new T;
                *(this->value) = value;
            }
            else {
                if (value < *(this->value)) {
                    if (this->left != NULL) // has left child
                        this->left->add(value);
                    else { // has no left child
                        this->left = new BST<T>;
                        this->left->value = new T;
                        this->left->parent = this;
                        *(this->left->value) = value;
                    }
                }
                else {
                    if (this->right != NULL) // has right child
                        this->right->add(value);
                    else { // has no right child
                        this->right = new BST<T>;
                        this->right->value = new T;
                        this->right->parent = this;
                        *(this->right->value) = value;
                    }
                }
            }
        }

        void inOrderDisplay() {
            if (this->left != NULL)
                this->left->inOrderDisplay();
            std::cout << *(this->value) << " ";
            if (this->right != NULL)
                this->right->inOrderDisplay();
        }

        BST<T>* search(T value) {
            if (*(this->value) == value)
                return this;
            else if (this->left != NULL && value < *(this->value))
                return this->left->search(value);
            else if (this->right != NULL && value > *(this->value))
                return this->right->search(value);
            else
                return NULL;
        }

        BST<T>* remove(T value) {
            BST<T>* node = search(value);

            if (node != NULL) {
                if (node->left == NULL && node->right == NULL) { // leaf node
                    delete node->value;
                    if (node->parent->left == node) // is left child
                        node->parent->left = NULL;
                    else // is right child
                        node->parent->right = NULL;
                    delete node;
                }

                // 1 child nodes
                if (node->left != NULL && node->right == NULL) { // has left child
                    if (node->parent->left == node) // is left child
                        node->parent->left = node->left;
                    else // is right child
                        node->parent->right = node->left;
                    delete node->value;
                    node->parent = NULL;
                    delete node;
                }

                if (node->left == NULL && node->right != NULL) { // has right child
                    if (node->parent->left == node) // is left child
                        node->parent->left = node->right;
                    else // is right child
                        node->parent->right = node->right;
                    delete node->value;
                    node->parent = NULL;
                    delete node;
                }

                // 2 children nodes
                if (node->left != NULL && node->right != NULL) {
                    T aux;
                    BST<T>* auxNode = node->right;

                    while (auxNode->left != NULL)
                    auxNode = auxNode->left;

                    aux = *(auxNode->value);

                    if (auxNode->right != NULL) {
                        *(auxNode->value) = *(auxNode->right->value);
                        auxNode->right->parent = NULL;
                        auxNode->right->value = NULL;
                        auxNode->right = NULL;
                        delete auxNode->right;
                    }
                    else {
                        if (auxNode->parent->left == auxNode) // is left child
                            auxNode->parent->left = NULL;
                        else // is right child
                            auxNode->parent->right = NULL;
                        auxNode->value = NULL;
                        delete auxNode;
                    }
                    *(node->value) = aux; 
                }
            }

            return this;
        }
};
#endif // BST_H

BST类的用法如下：

BST<int>* root = new BST<int>();

root->add(5);
root->add(2);
root->add(-17);

root->inOrderDisplay();

root->remove(5);

我提到所有方法都正常工作（我决定不发布它们，因为它们不是此问题的主题）。 问题是，当我使用Valgrind运行测试文件时，它会检测到一些内存泄漏，并且我确定它们是由于缺少适当的析构函数而发生的（上面的一个会产生分段错误）。

编辑：我添加了其他方法的代码

谢谢！

Answer 1

您的基本设计有点破损，至少是IMO。 也就是说，如果您愿意跳过足够多的步骤，则可以使其发挥作用，但是即使充其量也可能至少有点笨拙。

我将从为树中的节点定义一个单独的类开始。 然后，树本身将持有指向树根的指针，并定义树的大部分接口。

template <class T>
class Tree {

    struct node {
        node *parent;
        node *left;
        node *right;
        T *value;

        node(T *value) 
            : parent(nullptr), left(nullptr), right(nullptr), value(new T(value))
        {             
        }

        ~node() { 
            delete(left);
            delete(right);
            delete(value);
        }           
    } *root;

    Tree() : root(nullptr) {}

    ~Tree() { 
        delete(root);
    }
};

销毁不必显式递归。 例如， delete(left)将为左子节点（如果有）调用dtor，然后将为其子节点调用dtor，依此类推。 当到达叶节点时，我们将得到（相当于） delete nullptr; ，它定义为不执行任何操作，停止递归。

Answer 2

您应该换行：

            node->value = NULL;
            delete node->value;

像这样：

            delete node->value;
            node->value = NULL;

如果首先分配NULL不会删除任何内容。

Answer 3

很难找到的错误是您决定不查看的代码中的错误，因为您已经确信自己不相关。

无论如何，您的实现存在一个明显的问题：删除了很多其他内容之后，您基本上在做

class foo
{
    ~foo() { delete this; }
};

Answer 4

将RAII与unique_ptr结合使用可以避免这些问题：

template <typename T>
class BST{
public:
    BST() = default;
    ~BST() = default;

    BST(const BST&) = delete;
    BST& operator =(const BST&) = delete;
    BST(BST&&) = delete;
    BST& operator =(BST&&) = delete;

private:
    std::unique_ptr<BST<T>> left;
    std::unique_ptr<BST<T>> right;
    BST<T>* parent = nullptr;
    std::unique_ptr<T> value;
};