Question

所以我有一棵简单的树：

class MyNode
{
 public MyNode Parent;
 public IEnumerable<MyNode> Elements;
 int group = 1;
}

我有IEnumerable<MyNode>。我希望将所有MyNode的列表（包括内部节点对象（Elements））作为一个平面列表Where group == 1。如何通过LINQ做这样的事情？

Answer 1

你可以像这样展平一棵树：

IEnumerable<MyNode> Flatten(IEnumerable<MyNode> e) {
    return e.SelectMany(c => Flatten(c.Elements)).Concat(new[] {e});
}

然后，您可以使用group按Where(...)进行过滤。

要获得一些“风格点”，请将Flatten转换为静态类中的扩展函数。

public static IEnumerable<MyNode> Flatten(this IEnumerable<MyNode> e) {
    return e.SelectMany(c => c.Elements.Flatten()).Concat(e);
}

要为“更好的风格”获得一些积分，请将Flatten转换为采用树和生成后代的函数的通用扩展方法：

public static IEnumerable<T> Flatten<T>(
    this IEnumerable<T> e,
    Func<T,IEnumerable<T>> f) 
{
    return e.SelectMany(c => f(c).Flatten(f)).Concat(e);
}

像这样调用此函数：

IEnumerable<MyNode> tree = ....
var res = tree.Flatten(node => node.Elements);

如果您希望在预订中而不是在订购后进行展平，请切换Concat(...)的两侧。

Answer 2

接受答案的问题是，如果树很深，效率很低。如果树非常深，那么它会使堆栈爆炸。您可以使用显式堆栈来解决问题：

public static IEnumerable<MyNode> Traverse(this MyNode root)
{
    var stack = new Stack<MyNode>();
    stack.Push(root);
    while(stack.Count > 0)
    {
        var current = stack.Pop();
        yield return current;
        foreach(var child in current.Elements)
            stack.Push(child);
    }
}

假设高度为h的树中的n个节点和分支因子远小于n，则该方法在堆栈空间中为O（1），在堆空间中为O（h），在时间上为O（n）。给出的另一算法是堆栈中的O（h），堆中的O（1）和时间上的O（nh）。如果分支因子与n相比较小则则h在O（lg n）和O（n）之间，这说明如果h接近n，则天真算法可以使用危险量的堆栈和大量时间。

现在我们进行了遍历，您的查询非常简单：

root.Traverse().Where(item=>item.group == 1);

Answer 3

为了完整起见，这里是来自dasblinkenlight和Eric Lippert的答案的组合。单元测试和一切。： - ）

 public static IEnumerable<T> Flatten<T>(
        this IEnumerable<T> items,
        Func<T, IEnumerable<T>> getChildren)
 {
     var stack = new Stack<T>();
     foreach(var item in items)
         stack.Push(item);

     while(stack.Count > 0)
     {
         var current = stack.Pop();
         yield return current;

         var children = getChildren(current);
         if (children == null) continue;

         foreach (var child in children) 
            stack.Push(child);
     }
 }

Answer 4

<强>更新

对于对嵌套水平感兴趣的人（深度）。显式枚举器堆栈实现的一个好处是，在任何时刻（特别是当产生元素时）stack.Count表示当前的处理深度。因此，考虑到这一点并使用C＃7.0值元组，我们可以简单地更改方法声明如下：

public static IEnumerable<(T Item, int Level)> ExpandWithLevel<T>(
    this IEnumerable<T> source, Func<T, IEnumerable<T>> elementSelector)

和yield声明：

yield return (item, stack.Count);

然后我们可以通过在上面应用简单的Select来实现原始方法：

public static IEnumerable<T> Expand<T>(
    this IEnumerable<T> source, Func<T, IEnumerable<T>> elementSelector) =>
    source.ExpandWithLevel(elementSelector).Select(e => e.Item);

原文：

令人惊讶的是，没有人（甚至是埃里克）表现出自然的＆＃34;递归预订DFT的迭代端口，所以这里是：

    public static IEnumerable<T> Expand<T>(
        this IEnumerable<T> source, Func<T, IEnumerable<T>> elementSelector)
    {
        var stack = new Stack<IEnumerator<T>>();
        var e = source.GetEnumerator();
        try
        {
            while (true)
            {
                while (e.MoveNext())
                {
                    var item = e.Current;
                    yield return item;
                    var elements = elementSelector(item);
                    if (elements == null) continue;
                    stack.Push(e);
                    e = elements.GetEnumerator();
                }
                if (stack.Count == 0) break;
                e.Dispose();
                e = stack.Pop();
            }
        }
        finally
        {
            e.Dispose();
            while (stack.Count != 0) stack.Pop().Dispose();
        }
    }

Answer 5

如果其他人发现了这一点，但在他们将树木弄平之后也需要知道水平，这扩展了Konamiman的dasblinkenlight和Eric Lippert的解决方案的组合：

    public static IEnumerable<Tuple<T, int>> FlattenWithLevel<T>(
            this IEnumerable<T> items,
            Func<T, IEnumerable<T>> getChilds)
    {
        var stack = new Stack<Tuple<T, int>>();
        foreach (var item in items)
            stack.Push(new Tuple<T, int>(item, 1));

        while (stack.Count > 0)
        {
            var current = stack.Pop();
            yield return current;
            foreach (var child in getChilds(current.Item1))
                stack.Push(new Tuple<T, int>(child, current.Item2 + 1));
        }
    }

Answer 6

我发现这里给出的答案有一些小问题：

如果项目的初始列表为空怎么办？
如果子列表中有空值怎么办？

基于先前的答案，并提出以下建议：

public static class IEnumerableExtensions
{
    public static IEnumerable<T> Flatten<T>(
        this IEnumerable<T> items, 
        Func<T, IEnumerable<T>> getChildren)
    {
        if (items == null)
            yield break;

        var stack = new Stack<T>(items);
        while (stack.Count > 0)
        {
            var current = stack.Pop();
            yield return current;

            if (current == null) continue;

            var children = getChildren(current);
            if (children == null) continue;

            foreach (var child in children)
                stack.Push(child);
        }
    }
}

单元测试：

[TestClass]
public class IEnumerableExtensionsTests
{
    [TestMethod]
    public void NullList()
    {
        IEnumerable<Test> items = null;
        var flattened = items.Flatten(i => i.Children);
        Assert.AreEqual(0, flattened.Count());
    }
    [TestMethod]
    public void EmptyList()
    {
        var items = new Test[0];
        var flattened = items.Flatten(i => i.Children);
        Assert.AreEqual(0, flattened.Count());
    }
    [TestMethod]
    public void OneItem()
    {
        var items = new[] { new Test() };
        var flattened = items.Flatten(i => i.Children);
        Assert.AreEqual(1, flattened.Count());
    }
    [TestMethod]
    public void OneItemWithChild()
    {
        var items = new[] { new Test { Id = 1, Children = new[] { new Test { Id = 2 } } } };
        var flattened = items.Flatten(i => i.Children);
        Assert.AreEqual(2, flattened.Count());
        Assert.IsTrue(flattened.Any(i => i.Id == 1));
        Assert.IsTrue(flattened.Any(i => i.Id == 2));
    }
    [TestMethod]
    public void OneItemWithNullChild()
    {
        var items = new[] { new Test { Id = 1, Children = new Test[] { null } } };
        var flattened = items.Flatten(i => i.Children);
        Assert.AreEqual(2, flattened.Count());
        Assert.IsTrue(flattened.Any(i => i.Id == 1));
        Assert.IsTrue(flattened.Any(i => i == null));
    }
    class Test
    {
        public int Id { get; set; }
        public IEnumerable<Test> Children { get; set; }
    }
}

Answer 7

另一种选择是具有适当的OO设计。

例如要求MyNode返回所有拼合。

赞：

class MyNode
{
    public MyNode Parent;
    public IEnumerable<MyNode> Elements;
    int group = 1;

    public IEnumerable<MyNode> GetAllNodes()
    {
        if (Elements == null)
        {
            return new List<MyNode>(); 
        }

        return Elements.SelectMany(e => e.GetAllNodes());
    }
}

现在，您可以要求顶级MyNode获取所有节点。

var flatten = topNode.GetAllNodes();

如果您无法编辑课程，那么这不是一个选择。但是否则，我认为这可能是单独的（递归）LINQ方法的首选。

这是使用LINQ，所以我认为此答案适用于此;）

Answer 8

这里有一些可以使用Queue的现成的实现，可以先返回Flatten树，然后返回我的孩子。

public static IEnumerable<T> Flatten<T>(this IEnumerable<T> items, 
    Func<T,IEnumerable<T>> getChildren)
    {
        if (items == null)
            yield break;

        var queue = new Queue<T>();

        foreach (var item in items) {
            if (item == null)
                continue;

            queue.Enqueue(item);

            while (queue.Count > 0) {
                var current = queue.Dequeue();
                yield return current;

                if (current == null)
                    continue;

                var children = getChildren(current);
                if (children == null)
                    continue;

                foreach (var child in children)
                    queue.Enqueue(child);
            }
        }

    }

Answer 9

此处给出的大多数答案都产生depth-first或之字形序列。例如，从下面的树开始：

        1                   2 
       / \                 / \
      /   \               /   \
     /     \             /     \
    /       \           /       \
   11       12         21       22
  / \       / \       / \       / \
 /   \     /   \     /   \     /   \
111 112   121 122   211 212   221 222

dasblinkenlight的answer产生以下扁平化的序列：

111, 112, 121, 122, 11, 12, 211, 212, 221, 222, 21, 22, 1, 2

Konamiman的answer（概括了Eric Lippert的answer）产生了这种扁平化的序列：

2, 22, 222, 221, 21, 212, 211, 1, 12, 122, 121, 11, 112, 111

伊万·斯托耶夫（Ivan Stoev）的answer产生了以下扁平化序列：

1, 11, 111, 112, 12, 121, 122, 2, 21, 211, 212, 22, 221, 222

如果您对这样的breadth-first序列感兴趣：

1, 2, 11, 12, 21, 22, 111, 112, 121, 122, 211, 212, 221, 222

...那么这就是您的解决方案：

public static IEnumerable<T> Flatten<T>(this IEnumerable<T> source,
    Func<T, IEnumerable<T>> childrenSelector)
{
    var queue = new Queue<T>(source);
    while (queue.Count > 0)
    {
        var current = queue.Dequeue();
        yield return current;
        var children = childrenSelector(current);
        if (children == null) continue;
        foreach (var child in children) queue.Enqueue(child);
    }
}

实现上的区别基本上是使用Queue而不是Stack。没有实际的排序。

警告：就内存效率而言，此实现绝非最佳选择，因为在枚举过程中，大部分元素总数最终将存储在内部队列中。与基于Stack的实现相比，基于Queue的树遍历在内存使用方面效率更高。

Answer 10

void Main()
{
    var allNodes = GetTreeNodes().Flatten(x => x.Elements);

    allNodes.Dump();
}

public static class ExtensionMethods
{
    public static IEnumerable<T> Flatten<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> childrenSelector = null)
    {
        if (source == null)
        {
            return new List<T>();
        }

        var list = source;

        if (childrenSelector != null)
        {
            foreach (var item in source)
            {
                list = list.Concat(childrenSelector(item).Flatten(childrenSelector));
            }
        }

        return list;
    }
}

IEnumerable<MyNode> GetTreeNodes() {
    return new[] { 
        new MyNode { Elements = new[] { new MyNode() }},
        new MyNode { Elements = new[] { new MyNode(), new MyNode(), new MyNode() }}
    };
}

class MyNode
{
    public MyNode Parent;
    public IEnumerable<MyNode> Elements;
    int group = 1;
}

Answer 11

结合Dave和Ivan Stoev的答案，以防您需要嵌套级别并且列表变平并按顺序排列＆＃34;而不是像Konamiman给出的答案那样逆转。

 public static class HierarchicalEnumerableUtils
    {
        private static IEnumerable<Tuple<T, int>> ToLeveled<T>(this IEnumerable<T> source, int level)
        {
            if (source == null)
            {
                return null;
            }
            else
            {
                return source.Select(item => new Tuple<T, int>(item, level));
            }
        }

        public static IEnumerable<Tuple<T, int>> FlattenWithLevel<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> elementSelector)
        {
            var stack = new Stack<IEnumerator<Tuple<T, int>>>();
            var leveledSource = source.ToLeveled(0);
            var e = leveledSource.GetEnumerator();
            try
            {
                while (true)
                {
                    while (e.MoveNext())
                    {
                        var item = e.Current;
                        yield return item;
                        var elements = elementSelector(item.Item1).ToLeveled(item.Item2 + 1);
                        if (elements == null) continue;
                        stack.Push(e);
                        e = elements.GetEnumerator();
                    }
                    if (stack.Count == 0) break;
                    e.Dispose();
                    e = stack.Pop();
                }
            }
            finally
            {
                e.Dispose();
                while (stack.Count != 0) stack.Pop().Dispose();
            }
        }
    }

Answer 12

基于Konamiman的回答以及排序意外的评论，这里是一个带有显式排序参数的版本：

public static IEnumerable<T> TraverseAndFlatten<T, V>(this IEnumerable<T> items, Func<T, IEnumerable<T>> nested, Func<T, V> orderBy)
{
    var stack = new Stack<T>();
    foreach (var item in items.OrderBy(orderBy))
        stack.Push(item);

    while (stack.Count > 0)
    {
        var current = stack.Pop();
        yield return current;

        var children = nested(current).OrderBy(orderBy);
        if (children == null) continue;

        foreach (var child in children)
            stack.Push(child);
    }
}

示例用法：

var flattened = doc.TraverseAndFlatten(x => x.DependentDocuments, y => y.Document.DocDated).ToList();

Answer 13

下面是Ivan Stoev的代码，它具有告诉路径中每个对象的索引的附加功能。例如。搜索“Item_120”：

Item_0--Item_00
        Item_01

Item_1--Item_10
        Item_11
        Item_12--Item_120

将返回该项和一个int数组[1,2,0]。显然，嵌套级别也可用，作为数组的长度。

public static IEnumerable<(T, int[])> Expand<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> getChildren) {
    var stack = new Stack<IEnumerator<T>>();
    var e = source.GetEnumerator();
    List<int> indexes = new List<int>() { -1 };
    try {
        while (true) {
            while (e.MoveNext()) {
                var item = e.Current;
                indexes[stack.Count]++;
                yield return (item, indexes.Take(stack.Count + 1).ToArray());
                var elements = getChildren(item);
                if (elements == null) continue;
                stack.Push(e);
                e = elements.GetEnumerator();
                if (indexes.Count == stack.Count)
                    indexes.Add(-1);
                }
            if (stack.Count == 0) break;
            e.Dispose();
            indexes[stack.Count] = -1;
            e = stack.Pop();
        }
    } finally {
        e.Dispose();
        while (stack.Count != 0) stack.Pop().Dispose();
    }
}

Answer 14

我偶尔会尝试解决这个问题，并设计自己的解决方案以支持任意深度的结构（不进行递归），执行广度优先遍历并且不滥用过多的LINQ查询或对子级执行递归。在深入研究.NET source并尝试了许多解决方案之后，我终于提出了这个解决方案。最终结果与Ian Stoev的答案非常接近（我刚刚才看到它的答案），但是我的并没有利用无限循环或异常的代码流。

public static IEnumerable<T> Traverse<T>(
    this IEnumerable<T> source,
    Func<T, IEnumerable<T>> fnRecurse)
{
    if (source != null)
    {
        Stack<IEnumerator<T>> enumerators = new Stack<IEnumerator<T>>();
        try
        {
            enumerators.Push(source.GetEnumerator());
            while (enumerators.Count > 0)
            {
                var top = enumerators.Peek();
                while (top.MoveNext())
                {
                    yield return top.Current;

                    var children = fnRecurse(top.Current);
                    if (children != null)
                    {
                        top = children.GetEnumerator();
                        enumerators.Push(top);
                    }
                }

                enumerators.Pop().Dispose();
            }
        }
        finally
        {
            while (enumerators.Count > 0)
                enumerators.Pop().Dispose();
        }
    }
}

可以找到一个有效的示例here。

如何通过LINQ压扁树？

14 个答案: