Come posso attraversare un albero senza usare la ricorsione?

Ho un albero dei nodi di memoria molto grande e devo attraversare l'albero. Passando i valori restituiti di ciascun nodo figlio al nodo principale. Questo deve essere fatto fino a quando tutti i nodi hanno i loro dati in bolla sul nodo principale.

Traversal funziona così.

private Data Execute(Node pNode)
{
    Data[] values = new Data[pNode.Children.Count];
    for(int i=0; i < pNode.Children.Count; i++)
    {
        values[i] = Execute(pNode.Children[i]);  // recursive
    }
    return pNode.Process(values);
}

public void Start(Node pRoot)
{
    Data result = Execute(pRoot);
}

Funziona bene, ma sono preoccupato che lo stack di chiamate limiti le dimensioni dell'albero dei nodi.

Come si può riscrivere il codice in modo da non effettuare chiamate ricorsive Execute?

Ecco un'implementazione di attraversamento dell'albero per scopi generici che non utilizza la ricorsione:

public static IEnumerable<T> Traverse<T>(T item, Func<T, IEnumerable<T>> childSelector)
{
    var stack = new Stack<T>();
    stack.Push(item);
    while (stack.Any())
    {
        var next = stack.Pop();
        yield return next;
        foreach (var child in childSelector(next))
            stack.Push(child);
    }
}

Nel tuo caso puoi quindi chiamarlo così:

IEnumerable<Node> allNodes = Traverse(pRoot, node => node.Children);

Utilizzare prima una ricerca Queueanziché una Stacka, piuttosto che la profondità. Utilizzare a PriorityQueueper una migliore prima ricerca.

Se hai una stima della profondità del tuo albero in anticipo, forse è sufficiente per il tuo caso adattare le dimensioni dello stack? In C # dalla versione 2.0 questo è possibile ogni volta che inizi una nuova discussione, vedi qui:

http://www.atalasoft.com/cs/blogs/rickm/archive/2008/04/22/increasing-the-size-of-your-stack-net-memory-management-part-3.aspx

In questo modo puoi mantenere il tuo codice ricorsivo, senza dover implementare qualcosa di più complesso. Naturalmente, la creazione di una soluzione non ricorsiva con il proprio stack potrebbe essere più efficiente in termini di tempo e memoria, ma sono abbastanza sicuro che il codice non sarà così semplice come lo è per ora.

Non puoi attraversare una struttura di dati a forma di albero senza ricorrere alla ricorsione - se non usi i frame dello stack e le chiamate di funzione fornite dalla tua lingua, devi fondamentalmente programmare il tuo stack e le tue chiamate di funzione, ed è è improbabile che tu riesca a farlo all'interno della lingua in un modo più efficiente rispetto agli scrittori del compilatore sulla macchina su cui verrebbe eseguito il tuo programma.

Pertanto, evitare la ricorsione per paura di imbattersi nei limiti delle risorse è generalmente errato. A dire il vero , l'ottimizzazione prematura delle risorse è sempre sbagliata, ma in questo caso è probabile che anche se si misura e si conferma che l'utilizzo della memoria è il collo di bottiglia, probabilmente non sarà possibile migliorarlo senza scendere al livello del autore del compilatore.