【问题标题】:How to iterate through a tree structure using a generator?如何使用生成器遍历树结构?
【发布时间】:2010-09-28 22:08:31
【问题描述】:

我试图弄清楚如何在树节点中实现一个函数,该函数返回其所有后代叶子(无论是直接的还是间接的)。但是,我不想传递将递归放置叶节点的容器(树可能很大),而是我想使用生成器来遍历树。我尝试了几种方法,但到目前为止没有一种方法有效。这是我最接近可能的解决方案:

    public interface ITreeNode
    {
        IEnumerable<ITreeNode> EnumerateLeaves();            
    }

    class Leaf : ITreeNode
    {
        public IEnumerable<ITreeNode> EnumerateLeaves()
        {
            throw new NotImplementedException();
        }
    }

    class Branch : ITreeNode
    {
        private List<ITreeNode> m_treeNodes = new List<ITreeNode>();

        public IEnumerable<ITreeNode> EnumerateLeaves()
        {
            foreach( var node in m_treeNodes )
            {
                if( node is Leaf )
                    yield return node;
                else
                    node.EnumerateLeaves();
            }
        }
    }

但这也不起作用。我究竟做错了什么?如果同一函数中有 yield 语句,似乎递归调用 .EnumerateLeaves 将不起作用。

任何帮助将不胜感激。提前致谢。

编辑:我忘了提到一个分支可以有叶子或分支作为孩子,因此是递归。

【问题讨论】:

  • 是的 - 重新标记。 “编程”标签在编程站点上是多余的。 =)

标签: .net recursion iterator generator yield


【解决方案1】:

以下是您应该如何实现 Branch.EnumerateLeaves:

public IEnumerable<ITreeNode> EnumerateLeaves()
{
    foreach( var node in m_treeNodes )
    {
        if( node is Leaf )
            yield return node;
        else
        {
            foreach (ITreeNode childNode in node.EnumerateLeaves())
                yield return childNode;
        }
    }
}

【讨论】:

  • 这也行不通,因为一个分支可以有另一个分支作为子分支,这就是我使用递归的原因。
  • 那里,应该可以解决问题,现在它将正确使用递归。
  • 所以基本上解决方案是每次深入递归时创建一个新的生成器?
  • 那么这将是 O(n log n) 在树上的迭代?
  • 有关性能的更多信息,请参阅 Erik 的回答。与往常一样,分析代码,如果它是瓶颈,则重构它。
【解决方案2】:

lassevk 是对的 - 但是,该方法的一个潜在问题是递归调用可枚举对象会产生 O(n^2) 性能。如果这是一个问题,那么您应该将递归分解并使用内部堆栈。

public IEnumerable<ITreeNode> EnumerateLeaves()
{
    Stack<ITreeNode> workStack = new Stack<ITreeNode>(m_treeNodes);

    while(workStack.Count > 0) {
        var current = workStack.Pop();
        if(current is Leaf)
            yield return current;
        else {
            for(n = 0; n < current.m_treeNodes.Count; n++) {
                workStack.Push(current.m_treeNodes[n]);
            }
        }
    }
}

这应该执行相同的功能,没有递归。

编辑:Daniel Plaisted 在评论中发布了关于递归调用枚举器的更大问题的评论,总结为post on the MSDN Blogs regarding iterators。谢谢丹尼尔。 =)

另一个编辑:永远记住,代码的简单性可能比性能更重要,尤其是如果您希望其他人维护您的代码。如果您不希望您的树长得很大,请使用他的答案中概述的递归方法 lassevk。

【讨论】:

  • GC 并不是递归的最大问题,而是在每次迭代中它必须从顶部向下遍历枚举数的“树”。这可以使运行时间急剧增加。见blogs.msdn.com/wesdyer/archive/2007/03/23/…
  • 确实如此——虽然我想不出该如何表达。感谢您的链接 - 非常有帮助。 =)
【解决方案3】:

其他答案是正确的,但是在带有递归调用的 foreach 循环中返回 yield 的模式将使遍历树的运行时间类似于 O(节点数 * 节点的平均深度)。有关该问题的更多详细信息,请参阅this blog post。

这是对运行时和内存使用都有效的生成器的尝试:

class Node
{
    List<Node> _children;

    public bool IsLeaf { get { return _children.Count == 0; } }

    public IEnumerable<Node> Children { get { return _children; } }

    public IEnumerable<Node> EnumerateLeaves()
    {
        if (IsLeaf)
        {
            yield return this;
            yield break;
        }

        var path = new Stack<IEnumerator<Node>>();

        path.Push(Children.GetEnumerator());

        while(!path.Empty)
        {
            var cur = path.Pop();
            if (cur.MoveNext())
            {
                path.Push(cur);
                if (cur.IsLeaf)
                {
                    yield return cur;
                }
                else
                {
                    path.Push(cur.Children.GetEnumerator());
                }
            }

        }
    }

}

【讨论】:

  • 你能解释一下这比 O(n^2) 更好吗?我没看到。
  • O(n log n)。在您提供的链接中,递归深度为 n。在树中,一般情况下它是 log n。
  • 我更新了它,说明递归方法的运行时间是 O(节点数 * 节点的平均深度)。这个应该只有 O(节点数)的运行时间,这与 Erik 的相同。这个理论上有更少的内存使用。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2013-01-26
  • 1970-01-01
  • 1970-01-01
  • 2018-12-27
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多