How can I manage memory deallocation in disjoint sets in C++? - c++

Question

I have a set of classes to handle Disjoint sets in my C++ app. I have a hard time implementing the destructors for these classes. Can anyone help me on that?
What these basically do is: put nodes' pointers into NodeAddress[], every node is distinguished by its val. Every node has a pointer to the Item which is a placeholder for hd head and tl tail of the disjoint set.
I want to mention that I realize that there are some issues with e.g. : variable visibility ( public access ), constant size NodeAddress buffer but I want to focus here on memory deallocation.
And yes I want (need) to do it on pointer (no STL). If you have sny suggestions or questions feel free to comment.
This is the code :
header
class ListSet {
public:
unsigned int size;
node* NodeAddress[MAX_NUMBER_OF_LABELS];
struct Item;
class node {
public:
unsigned int val;
node *next;
Item *itemPtr;
node () : val(0), next(0), itemPtr(0) {}
node (const int& a) : val(a), next(0), itemPtr(0) {}
};
struct Item {
public:
node *hd, *tl;
Item(node *shd) : hd(shd), tl(shd) {}
void ListSet::Item::append (const Item* other);
//removal
ListSet::node* remove(node* old);
};
ListSet()
{
this->size = 0;
memset(NodeAddress, 0, sizeof(NodeAddress));
}
void setNodeAddress(const int& a, node* shd)
{
NodeAddress[a] = shd;
}
node* getNodeAddress(const int& a)
{
return NodeAddress[a];
}
ListSet::Item* ListSet::makeSet (const int& a) ;
ListSet::Item* ListSet::find (const int& a);
ListSet::Item* ListSet::unionSets (Item* s1, Item* s2);
void ListSet::unionSets (const int& a1, const int& a2);
};
source
void ListSet::Item::append (const Item* other) {
//join the tail of the set to head of the other set
tl->next = other->hd;
tl = other->tl;
for (node* cur = other->hd; cur; cur = cur->next) {
cur->itemPtr = this;
}
}
ListSet::Item* ListSet::makeSet (const int& a) {
if( a > this->size) {this->size = a;}
assert(!getNodeAddress(a));
node *shd = new node(a);
Item *newSet = new Item(shd);
setNodeAddress(a, shd);
shd->itemPtr = newSet;
return newSet;
}
ListSet::Item* ListSet::find (const int& a) {
node* ptr = getNodeAddress(a);
if (ptr)
return ptr->itemPtr;
return 0;
}
ListSet::Item* ListSet::unionSets (Item* s1, Item* s2) {
Item *set1 = s1;
Item *set2 = s2;
set2->append(set1);
delete set1;
return set2;
}
void ListSet::unionSets (const int& a1, const int& a2) {
Item* s1 = find(a1);
Item* s2 = find(a2);
if (s1 && s2) {
(void) unionSets(s1, s2);
}
}
*EDIT: *
there is something that I have but is not working
ListSet::node* ListSet::Item::remove(node* old) {
if (old == hd) {
if (old == tl) {
assert(! old->next);
return 0;
}
assert(old->next);
hd = old->next;
} else {
node* prev;
for (prev = hd; prev->next != old; prev = prev->next) {
assert(prev->next);
;
}
if (old == tl) {
assert(! old->next);
//
tl = prev;
prev->next = 0;
} else {
assert(old->next);
prev->next = old->next;
}
}
return hd;
}
ListSet::node::~node() {
if (itemPtr) {
if (! itemPtr->remove(this)) {
// Don't leak an empty set.
delete itemPtr;
}
}
}
void ListSet::remove(const int& a) {
node* ptr = getNodeAddress(a);
if (ptr) {
setNodeAddress(a, 0);
delete ptr;
}
// else error?
}

Answer 1

Your code is overly complicated. Here's my take on a disjoint set forest; all memory management can be handled from the outside by putting the sets in a vector. Note that no pointer manipulation is needed, because a set can be uniquely identified by a size_t-typed index into the forest.