What wrong with my Red Black Tree destructor? - c++

Question

I'm building a Red-Black Tree, but may be there are some problems with my class RBTree's destructor. I add 10^7 value to the tree, and then call the destructor, but the memory seem to be not freed up. (I look at the System Monitor and my program still use 200MB).
Could you tell me what is wrong with my destructor. This is my source code.
Sorry for my poor English.
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
enum Color {RED, BLACK};
template<class Data> class RBNode;
template<class Data> class RBTree;
template<class Data> class RBNode {
Color color; RBNode *p, *left, *right;
public:
Data v;
RBNode(Color color, RBNode *p, RBNode *left, RBNode *right, Data v):
color(color), p(p), left(left), right(right), v(v) {}
RBNode() {}
friend class RBTree<Data>;
};
template<class Data> class RBTree {
typedef RBNode<Data> Node;
typedef Node * PNode;
PNode root, nil;
void LeftRotate(PNode x) {
PNode y = x->right; x->right = y->left;
if(y->left != nil) y->left->p = x;
y->p = x->p;
if(x->p == nil) root = y;
else if(x == x->p->left) x->p->left = y;
else x->p->right = y;
y->left = x; x->p = y;
}
void RightRotate(PNode y) {
PNode x = y->left; y->left = x->right;
if(x->right != nil) x->right->p = y;
x->p = y->p;
if(y->p == nil) root = x;
else if(y == y->p->left) y->p->left = x;
else y->p->right = x;
x->right = y; y->p = x;
}
void insertFixUp(PNode z) {
while(z->p->color == RED) {
if(z->p == z->p->p->left) {
PNode y = z->p->p->right;
if(y->color == RED) z->p->color = y->color = BLACK, z->p->p->color = RED, z = z->p->p;
else {
if(z == z->p->right) LeftRotate(z = z->p);
z->p->color = BLACK; z->p->p->color = RED; RightRotate(z->p->p);
}
} else {
PNode y = z->p->p->left;
if(y->color == RED) z->p->color = y->color = BLACK, z->p->p->color = RED, z = z->p->p;
else {
if(z == z->p->left) RightRotate(z = z->p);
z->p->color = BLACK; z->p->p->color = RED; LeftRotate(z->p->p);
}
}
}
root->color = BLACK;
}
public:
RBTree() {
nil = new Node;
nil->color = BLACK;
nil->p = nil->left = nil->right = nil;
nil->v = Data();
root = nil;
}
~RBTree() {
delete root;
delete nil;
}
void insert(Data v) {
PNode y = nil, x = root;
while(x != nil) {
y = x;
x = v < x->v ? x->left : x->right;
}
PNode z = new Node; *z = Node(RED, y, nil, nil, v);
if(y == nil) root = z;
else if(v < y->v) y->left = z;
else y->right = z;
insertFixUp(z);
}
};
int main() {
RBTree<int> tree;
for(int i = 0; i < 10000000; ++i) tree.insert(i);
tree.~RBTree();
getchar();
return 0;
}

Answer 1

You need to add a destructor to your RBNode, which deletes its children:
template<class Data> class RBNode {
...
~RBNode() {
delete left;
delete right;
}
...
};
As is, you will delete the root node when the tree is deleted, but the root node itself doesn't free its resources. Because of this, you lose all references to the child nodes of root, and all their child nodes, etc. Because you no longer have a reference to these nodes, you can't delete them, you have a memory leak.
The destructor ensures that when we're about to lose our references to a node's children, these children get freed (and their children and so on).

Answer 2

First, what's wrong with it is that you did not use a smart pointer. Secondly, you did not use a smart pointer in your Node classes, so when the root is deleted, none of the other objects are deleted.

Answer 3

Your tree nodes don't appear to recursively delete their children. You need a destructor in the node and then everything will cascade when the root gets destroyed.

Answer 4

Your destructor only frees up two elements: root and nil. To free up the rest of the tree, you should somehow propagate freeing up the elements down the tree, like:
~RBNode() {
if (left != nil ) delete left;
if (right != nil) delete right;
}
(this is just the idea, of course this code won't literally work because you don't see nil in the destructor).

Answer 5

I found my destructor, but i had some more attributes, like size and the parent pointer, but i think it will help
~RBTree() {
RBNode *p(root);
while(size!=0) {
if(p==root && size==1) { delete root; size--;}
else if(p->right!=0) p=p->right;
else if(p->left!=0) p=p->left;
else {
RBNode *c(p);
p=p->parent;
if(p->left==c) {
delete c;
p->left=0;
}
else {
delete c;
p->right=0;
}
size--;
}
}
}