Binary search tree recursive destructor - c++

Question

I have checked other similar topics, but none seemed to help me.
I am trying to write a destructor for this specific BST implementation. Every node contains a pointer to the parent, a pointer to the left node, a pointer to the right node and a pointer to the value it contains.
This is how the beginning of the class looks:
#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
The BST class is used as below:
BST<int>* root = new BST<int>();
root->add(5);
root->add(2);
root->add(-17);
root->inOrderDisplay();
root->remove(5);
I mention that all the methods work properly (I decided not to post them, since they are not the subject of this question). The problem is that when I run my test file with Valgrind, it detects some memory leaks and I am sure that they occur because of the lack of a proper destructor (the above one produces a segmentation fault).
EDIT: I added the code for the other methods
Thank you!

Answer 1

Your basic design is kind of broken, at least IMO. That is, if you're willing to jump through enough hoops, you can probably make it work, but even at best it'll probably always be at least a little clumsy to work with.
I'd start by defining a separate class for the nodes in the tree. Then the tree itself will hold a pointer to the root of the tree and define most of the interface to the tree.
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);
}
};
Destruction doesn't have to be explicitly recursive. The delete(left) (for example) will invoke the dtor for the left child node (if there is one) and that'll invoke the dtor for its child nodes, and so on. When we reach a leaf node, we'll end up with (the equivalent of) delete nullptr;, which is defined as doing nothing, stopping the recursion.

Answer 2

You should swap the lines:
node->value = NULL;
delete node->value;
Like this:
delete node->value;
node->value = NULL;
if you first assign NULL you delete nothing.

Answer 3

The hardest bugs to find are the ones in the code you've decided not to look at because you've convinced yourself they're not relevant.
Anyways, there is one evident problem with your implementation: after removing a bunch of other stuff, you are basically doing
class foo
{
~foo() { delete this; }
};

Answer 4

Use RAII with unique_ptr to avoid those issues:
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;
};