Binary Search Tree Traversal - preorder

Question

Binary Search Tree Traversal - preorder

stemmen

8

Ik probeer implementeren Tree Traversal preorder behulp rendementen die een IEnumerable terugkeert

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 dit geval, het gaat in oneindige lus en ja ik weet dat ik moet oversteken te houden. Hoe kan dit worden gedaan?

Als de LeftChild of RightChild nul is, gooit een null uitzondering. Ik denk dat op dat punt ik moet opleveren break;

Ik neem aan, inorder en postorder zou te gelijk zijn, geen ideeën?

Ik heb de Resursive versie, die goed werkt.

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

Bedankt.

c#.net algorithm tree binary-search-tree

De vraag is gesteld op 04/06/2011 om 03:34
bron van user DarthVader

In andere talen...

1 antwoorden

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

Optie # 1 Recursieve

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

Gebruik:

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

Optie # 2 Niet-recursieve 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);
    }
}