二进制搜索树递归析构函数
Binary search tree recursive destructor
我检查过其他类似的主题，但似乎没有任何帮助。
我正试图为这个特定的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运行我的测试文件时，它检测到一些内存泄漏，我确信它们的发生是因为缺乏合适的析构函数（上面的析构因子会产生分段错误）。
编辑：我添加了其他方法的代码
谢谢！
你的基本设计有点破了，至少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;，它被定义为什么都不做，停止递归。
您应该交换行：
node->value = NULL;
delete node->value;
像这样：
delete node->value;
node->value = NULL;
如果您首先指定NULL，则不会删除任何内容。
最难找到的bug是代码中那些你决定不看的bug，因为你确信它们不相关。
无论如何，你的实现有一个明显的问题：在删除了一堆其他东西之后，你基本上就是在做
class foo
{
~foo() { delete this; }
};
将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;
};
相关文章：
- 什么时候调用组成单元对象的析构函数
- 如果C++类在类方法中具有动态分配，但没有构造函数/析构函数或任何非静态成员，那么它仍然是POD类型吗
- 内联映射初始化的动态atexit析构函数崩溃
- 递归导致程序崩溃，但 while 循环中的相同概念不是来自C++析构函数
- 递归列表:调用析构函数的所有内容
- 这个递归类需要一个自定义析构函数?
- 链表的递归析构函数
- C++二进制树递归析构函数问题
- 是否可以在容器之类的堆栈中创建非递归析构函数
- 析构函数、图和递归性
- 是否应始终在析构函数中清除/归零成员数据
- 二叉树析构函数的递归调用
- 二叉树的递归析构函数
- C++中的慢速递归析构函数调用
- 指向"raw"资源的指针是否应该在析构函数中归零？
- C++中的递归析构函数
- 使用堆栈的非递归析构函数二叉搜索树
- 如何在递归选择排序算法中调用类析构函数
- 是链表、树等的递归析构函数
- 二进制搜索树递归析构函数
