我尝试使用yield return实现Tree Traversal PreOrder,返回一个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;
}
}
在这种情况下,它进入无限循环,是的,我知道我需要继续遍历。怎么办呢?
如果LeftChild或RightChild为null,则抛出null异常。我认为那时我需要收益率突破;
我认为,inorder和postorder也会有类似的想法吗?
我有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);
}
}
感谢。
答案 0 :(得分:4)
选项#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);
}
}