[C++] Albero generico - calcolo profondità

[MegaAlchimista]

Come da titolo devo implementare in C++ una classe che rappresenti un albero generico con un metodo che mi restituisca la profondità
(La radice r ha profondità 0, i suoi figli hanno profondità 1, i nipoti profondità 2 e così via).

La classe albero ha una interfaccia molto semplice:
(GLinkedList è una classe creata da me che consiste semplicemente in una lista linkata)

#include "GLinkedList.h"
template<class T> class GTreeIterator;    //questa classe serve per navigare attraverso l'albero, aggiungere figli, leggere e settare i valori dei nodi. Non la riporto per brevità

//----------------------------------------------------------------------------------------
//Class GTree : every node stores one <dataType> , have one parent and a list of children
//----------------------------------------------------------------------------------------
template<class T> class GTree
{
	friend class GTreeIterator<T>;
	typedef GTree<T> Node;
public:
	GTree(void)							: _parent(nullptr)			{}
	explicit GTree(const T& nodeValue)	: _data(nodeValue), _parent(nullptr)	{}
	virtual ~GTree(void)						            {clearChildren();}

	//delete all children from this node
	inline void clearChildren()
	{
		//salto il codice per brevità
	}

	//return total number of nodes
	inline int size()	const
	{
		//salto il codice per brevità
	}
	inline const T& value() const		{return _data;}
	inline void setValue(const T& v)	{_data=v;}
	inline bool haveChildren() const	{return !_children.isEmpty();}

	//0==only root, 1==root children are leafs, and so on
	int depth() const;
private:
        //TODO: copy
	GTree(const GTree<T>&);										
	GTree<T>& operator=(const GTree<T>&);

	T _data;
	Node* _parent;
	GLinkedList<Node*> _children;
};	//EO class GTree

al momento ho implementato la funzione depth() in questo modo: ma ritorna sempre dei valori più alti di quanto dovrebbe

template<class T> int GTree<T>::depth() const
{
	if( haveChildren() )
	{
		int c =1, temp=0;
		GList_ConstIterator<Node*> itr = _children.const_begin();
		while( itr.isValid() )
		{
                        //itr.data() in questo caso resituisce un puntatore al nodo figlio
			temp += itr.data()->depth();
			++itr;
			if(temp>c)
				c=temp;
		}
		return c;
	}
	else
		return 0;
}

Quello che ho pensato di fare è questo:
Se un nodo non ha figli torno 0.
Se ha figli:
- controllo ogni figlio
- richiamo la funzione in modo ricorsivo in modo da controllare tutti i nodi
- prendo il valore massimo (sostanzialmente il figlio che ha più nipoti)

spero che qualcuno possa aiutarmi perchè mi sento vicino alla soluzione ma non riesco a vedere l'errore nel mio ragionamento.
Grazie anticipatamente

[MegaAlchimista]

Ho risolto utilizzando un altro approccio.

Ho creato una funzione (che ho chiamato nodeDepth) che mi restituisce la profondità di un nodo (semplicemente vado dal nodo in questione fino alla radice ed aumento un contatore ogni volta che mi sposto).

Nella funzione depth invece faccio uno scan su tutti i nodi dell'albero:
faccio tornare nodeDepth() se sono su una foglia e depth() su ogni figlio se sono su un nodo qualsiasi.

In questo modo in modo ricorsivo arrivo alle foglie e poi restituisco il valore più alto.

Se volete potete chiudere