Question

I have recently managed to get a stack overflow when destroying a tree by deleting its root ‘Node’, while the Node destructor is similar to this:

Node::~Node(){
    for(int i=0;i<m_childCount;i++)
        delete m_child[i];
}

A solution that come up into my mind was to use own stack. So deleting the tree this way:

std::stack< Node* > toDelete;

if(m_root)
    toDelete.push(m_root);

while(toDelete.size()){
    Node *node = toDelete.top();
    toDelete.pop();

    for(int i=0;i<node->GetChildCount();i++)
        toDelete.push(node->Child(i));

    delete node;
}

But in there the std::stack::push() may throw an exception. Is it possible to write an exception free tree destruction? How?

EDIT:

If anybody is interested here is an exception free non-recursive code inspired by the algorithm pointed out by jpalecek:

Node *current = m_root;

while(current){
  if(current->IsLeaf()){
    delete current;
    return;
  }

  Node *leftMostBranch = current;// used to attach right subtrees

  // delete all right childs
  for(size_t i=1; i<current->GetChildCount(); i++){
    while(!leftMostBranch->Child(0)->IsLeaf())
      leftMostBranch = leftMostBranch->Child(0);

    delete leftMostBranch->Child(0);
    leftMostBranch->Child(0) = current->Child(i);
  }

  // delete this node and advance to the left child
  Node *tmp = current;
  current = current->Child(0);
  delete tmp;
}

note: Node::IsLeaf() is equivalent to Node::GetChildCount()!=0.

Answer 1

This is what all garbage collectors struggle with. However, the best thing you can do (IMHO) is to pray for enough memory for the stack, and your prayers will be heard 99.99999% of the time. Should it not happen, just abort().

BTW if you are interested, there is a solution to traverse long (and deep) trees without allocating much memory.