द्विआधारी खोज वृक्ष Traversal - Preorder

Question

द्विआधारी खोज वृक्ष Traversal - Preorder

वोट

8

मैं उपज वापसी जो एक IEnumerable देता है का उपयोग कर पेड़ Traversal Preorder को लागू करने की कोशिश कर रहा हूँ

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

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

}

इस मामले में, यह अनंत लूप में चला जाता है और हाँ मुझे पता है कि मैं traversing रखने की जरूरत है। यह कैसे किया जा सकता है?

LeftChild या RightChild रिक्त है, तो एक अशक्त अपवाद फेंकता है। मैं उस समय मैं ब्रेक उपज की जरूरत है पर लगता है;

मुझे लगता है, inorder और क्रंमोत्तर भी समान होगा, किसी भी विचार?

मैं Resursive संस्करण, कि अच्छी तरह से काम करता है।

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

धन्यवाद।

c#.net algorithm tree binary-search-tree

04/06/2011 को 03:34
का स्रोत उपयोगकर्ता DarthVader

अन्य भाषाओं में...

1 जवाब

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

विकल्प # 1 रिकर्सिव

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

उपयोग:

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

विकल्प # 2 गैर-पुनरावर्ती स्थिर विधि

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