Binäre Suche Baum Traversal - PreOrder

Question

Binäre Suche Baum Traversal - PreOrder

stimmen

8

Ich versuche Baum Traversal PreOrder mit Ertrag Rückkehr zu implementieren, die gibt eine IEnumerable

private IEnumerable<T> Preorder(Node<T> node)
{

    while(node != null)
    {
        yield return node.Data;
        yield return node.LeftChild.Data;
        yield return node.RightChild.Data;
    }

}

In diesem Fall geht es in Endlosschleife und ja, ich weiß, dass ich Verfahrgeschwindigkeit halten müssen. Wie kann dies geschehen?

Wenn die LeftChild oder RightChild null ist, wirft eine Null Ausnahme. Ich denke, an diesem Punkt i Pause ergeben müssen;

Ich gehe davon aus, inorder und Postorder würde zu ähnlich sein, irgendwelche Ideen?

Ich habe die Resursive Version, die gut funktioniert.

public void PreOrderTraversal(Node<T> node)
{

    if(node!=null)
    {
        Console.Write(node.Data);
    }
    if (node.LeftChild != null)
    {
        PreOrderTraversal(node.LeftChild);
    }

    if (node.RightChild != null)
    {
        PreOrderTraversal(node.RightChild);
    }
}

Vielen Dank.

c#.net algorithm tree binary-search-tree

Veröffentlicht am 04/06/2011 um 03:34
quelle vom benutzer DarthVader

In anderen Sprachen...

1 antworten

Alex Aza · Accepted Answer · 2011-06-04 04:04

Option # 1 rekursive

public class Node<T> : IEnumerable<T>
{
    public Node<T> LeftChild { get; set; }

    public Node<T> RightChild { get; set; }

    public T Data { get; set; }

    public IEnumerator<T> GetEnumerator()
    {
        yield return Data;

        if (LeftChild != null)
        {
            foreach (var child in LeftChild)
                yield return child;
        }
        if (RightChild != null)
        {
            foreach (var child in RightChild)
                yield return child;
        }
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Verwendung:

var child1 = new Node<int> { Data = 1 };
var child2 = new Node<int> { Data = 2 };
var child3 = new Node<int> { Data = 3, LeftChild = child1 };
var root = new Node<int> { Data = 4, LeftChild = child3, RightChild = child2 };

foreach (var value in root)
    Console.WriteLine(value);

Option # 2 Non-recursive statische Methode

public static IEnumerable<T> Preorder<T>(Node<T> root)
{
    var stack = new Stack<Node<T>>();
    stack.Push(root);

    while (stack.Count > 0)
    {
        var node = stack.Pop();
        yield return node.Data;
        if (node.RightChild != null)
            stack.Push(node.RightChild);
        if (node.LeftChild != null)
            stack.Push(node.LeftChild);
    }
}