Bagaimana cara melintasi pohon tanpa menggunakan rekursi?

Saya memiliki pohon simpul memori yang sangat besar dan perlu melintasi pohon. Melewati nilai yang dikembalikan dari setiap simpul anak ke simpul induknya. Ini harus dilakukan sampai semua node memiliki data bubble hingga ke root node.

Traversal bekerja seperti ini.

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);
}

Ini berfungsi dengan baik, tapi saya khawatir bahwa tumpukan panggilan membatasi ukuran pohon simpul.

Bagaimana kode dapat ditulis ulang sehingga tidak ada panggilan rekursif untuk Executedilakukan?

Berikut adalah implementasi pohon traversal tujuan umum yang tidak menggunakan rekursi:

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);
    }
}

Dalam kasus Anda, Anda dapat menyebutnya seperti ini:

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

Gunakan pencarian Queuebukan Stackuntuk bernafas terlebih dahulu, bukan kedalaman terlebih dahulu. Gunakan PriorityQueueuntuk pencarian pertama yang terbaik.

Jika Anda memiliki perkiraan untuk kedalaman pohon Anda sebelumnya, mungkin itu cukup untuk kasus Anda untuk mengadaptasi ukuran tumpukan? Di C # sejak versi 2.0 ini dimungkinkan setiap kali Anda memulai utas baru, lihat di sini:

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

Dengan begitu Anda dapat menyimpan kode rekursif Anda, tanpa harus mengimplementasikan sesuatu yang lebih kompleks. Tentu saja, membuat solusi non-rekursif dengan tumpukan Anda sendiri mungkin lebih hemat waktu dan memori, tetapi saya cukup yakin kodenya tidak akan sesederhana seperti saat ini.

Anda tidak dapat melintasi struktur data dalam bentuk pohon tanpa menggunakan rekursi - jika Anda tidak menggunakan frame stack dan panggilan fungsi yang disediakan oleh bahasa Anda, pada dasarnya Anda harus memprogram stack dan panggilan fungsi Anda sendiri, dan itu adalah tidak mungkin Anda berhasil melakukannya dalam bahasa dengan cara yang lebih efisien daripada penulis kompiler lakukan pada mesin yang menjalankan program Anda.

Karena itu, menghindari rekursi karena takut berlari ke batas sumber daya biasanya salah arah. Yang pasti, optimasi sumber daya prematur selalu salah arah, tetapi dalam kasus ini kemungkinan bahwa bahkan jika Anda mengukur dan mengonfirmasi bahwa penggunaan memori adalah hambatan, Anda mungkin tidak akan dapat meningkatkannya tanpa jatuh ke tingkat penulis kompiler.