Durchsuchen eines Baums mit LINQ

Ich habe einen Baum aus dieser Klasse erstellt.

class Node
{
    public string Key { get; }
    public List<Node> Children { get; }
}

Ich möchte alle Kinder und alle ihre Kinder durchsuchen, um diejenigen zu finden, die einer Bedingung entsprechen:

node.Key == SomeSpecialKey

Wie kann ich es implementieren?

Es ist ein Missverständnis, dass dies eine Rekursion erfordert. Es wird einen Stapel oder eine Warteschlange erfordern, und der einfachste Weg besteht darin, ihn mithilfe der Rekursion zu implementieren. Der Vollständigkeit halber werde ich eine nicht rekursive Antwort geben.

static IEnumerable<Node> Descendants(this Node root)
{
    var nodes = new Stack<Node>(new[] {root});
    while (nodes.Any())
    {
        Node node = nodes.Pop();
        yield return node;
        foreach (var n in node.Children) nodes.Push(n);
    }
}

Verwenden Sie diesen Ausdruck zum Beispiel, um ihn zu verwenden:

root.Descendants().Where(node => node.Key == SomeSpecialKey)

Durchsuchen eines Objektbaums mit Linq

public static class TreeToEnumerableEx
{
    public static IEnumerable<T> AsDepthFirstEnumerable<T>(this T head, Func<T, IEnumerable<T>> childrenFunc)
    {
        yield return head;

        foreach (var node in childrenFunc(head))
        {
            foreach (var child in AsDepthFirstEnumerable(node, childrenFunc))
            {
                yield return child;
            }
        }

    }

    public static IEnumerable<T> AsBreadthFirstEnumerable<T>(this T head, Func<T, IEnumerable<T>> childrenFunc)
    {
        yield return head;

        var last = head;
        foreach (var node in AsBreadthFirstEnumerable(head, childrenFunc))
        {
            foreach (var child in childrenFunc(node))
            {
                yield return child;
                last = child;
            }
            if (last.Equals(node)) yield break;
        }

    }
}

Wenn Sie die Linq-ähnliche Syntax beibehalten möchten, können Sie eine Methode verwenden, um alle Nachkommen (Kinder + Kinder Kinder usw.) zu erhalten.

static class NodeExtensions
{
    public static IEnumerable<Node> Descendants(this Node node)
    {
        return node.Children.Concat(node.Children.SelectMany(n => n.Descendants()));
    }
}

Diese Aufzählung kann dann wie jede andere mit where oder first oder was auch immer abgefragt werden.

Sie können diese Erweiterungsmethode ausprobieren, um die Baumknoten aufzulisten:

static IEnumerable<Node> GetTreeNodes(this Node rootNode)
{
    yield return rootNode;
    foreach (var childNode in rootNode.Children)
    {
        foreach (var child in childNode.GetTreeNodes())
            yield return child;
    }
}

Verwenden Sie das dann mit einer Where()Klausel:

var matchingNodes = rootNode.GetTreeNodes().Where(x => x.Key == SomeSpecialKey);

Vielleicht brauchst du nur

node.Children.Where(child => child.Key == SomeSpecialKey)

Oder, wenn Sie eine Ebene tiefer suchen müssen,

node.Children.SelectMany(
        child => child.Children.Where(child => child.Key == SomeSpecialKey))

Wenn Sie auf allen Ebenen suchen müssen, gehen Sie wie folgt vor:

IEnumerable<Node> FlattenAndFilter(Node source)
{
    List<Node> l = new List();
    if (source.Key == SomeSpecialKey)
        l.Add(source);
    return
        l.Concat(source.Children.SelectMany(child => FlattenAndFilter(child)));
}

public class Node
    {
        string key;
        List<Node> children;

        public Node(string key)
        {
            this.key = key;
            children = new List<Node>();
        }

        public string Key { get { return key; } }
        public List<Node> Children { get { return children; } }

        public Node Find(Func<Node, bool> myFunc)
        {
            foreach (Node node in Children)
            {
                if (myFunc(node))
                {
                    return node;
                }
                else 
                {
                    Node test = node.Find(myFunc);
                    if (test != null)
                        return test;
                }
            }

            return null;
        }
    }

Und dann können Sie suchen wie:

    Node root = new Node("root");
    Node child1 = new Node("child1");
    Node child2 = new Node("child2");
    Node child3 = new Node("child3");
    Node child4 = new Node("child4");
    Node child5 = new Node("child5");
    Node child6 = new Node("child6");
    root.Children.Add(child1);
    root.Children.Add(child2);
    child1.Children.Add(child3);
    child2.Children.Add(child4);
    child4.Children.Add(child5);
    child5.Children.Add(child6);

    Node test = root.Find(p => p.Key == "child6");

Warum nicht eine IEnumerable<T>Erweiterungsmethode verwenden?

public static IEnumerable<TResult> SelectHierarchy<TResult>(this IEnumerable<TResult> source, Func<TResult, IEnumerable<TResult>> collectionSelector, Func<TResult, bool> predicate)
{
    if (source == null)
    {
        yield break;
    }
    foreach (var item in source)
    {
        if (predicate(item))
        {
            yield return item;
        }
        var childResults = SelectHierarchy(collectionSelector(item), collectionSelector, predicate);
        foreach (var childItem in childResults)
        {
            yield return childItem;
        }
    }
}

dann mach das einfach

var result = nodes.Children.SelectHierarchy(n => n.Children, n => n.Key.IndexOf(searchString) != -1);

Vor einiger Zeit schrieb ich einen Artikel über ein Codeprojekt, in dem beschrieben wird, wie mit Linq baumartige Strukturen abgefragt werden:

http://www.codeproject.com/KB/linq/LinqToTree.aspx

Dies bietet eine Linq-to-XML-API, mit der Sie Nachkommen, Kinder, Vorfahren usw. suchen können.

Wahrscheinlich übertrieben für Ihr aktuelles Problem, könnte aber für andere von Interesse sein.

Mit dieser Erweiterungsmethode können Sie den Baum abfragen.

    public static IEnumerable<Node> InTree(this Node treeNode)
    {
        yield return treeNode;

        foreach (var childNode in treeNode.Children)
            foreach (var flattendChild in InTree(childNode))
                yield return flattendChild;
    }

Ich habe eine generische Erweiterungsmethode, die jede reduzieren kann, IEnumerable<T>und aus dieser reduzierten Sammlung können Sie den gewünschten Knoten erhalten.

public static IEnumerable<T> FlattenHierarchy<T>(this T node, Func<T, IEnumerable<T>> getChildEnumerator)
{
    yield return node;
    if (getChildEnumerator(node) != null)
    {
        foreach (var child in getChildEnumerator(node))
        {
            foreach (var childOrDescendant in child.FlattenHierarchy(getChildEnumerator))
            {
                yield return childOrDescendant;
            }
        }
    }
}

Verwenden Sie dies wie folgt:

var q = from node in myTree.FlattenHierarchy(x => x.Children)
        where node.Key == "MyKey"
        select node;
var theNode = q.SingleOrDefault();

Ich verwende die folgenden Implementierungen zum Auflisten von Tree-Elementen

    public static IEnumerable<Node> DepthFirstUnfold(this Node root) =>
        ObjectAsEnumerable(root).Concat(root.Children.SelectMany(DepthFirstUnfold));

    public static IEnumerable<Node> BreadthFirstUnfold(this Node root) {
        var queue = new Queue<IEnumerable<Node>>();
        queue.Enqueue(ObjectAsEnumerable(root));

        while (queue.Count != 0)
            foreach (var node in queue.Dequeue()) {
                yield return node;
                queue.Enqueue(node.Children);
            }
    }

    private static IEnumerable<T> ObjectAsEnumerable<T>(T obj) {
        yield return obj;
    }

BreadthFirstUnfold verwendet in der obigen Implementierung die Warteschlange der Knotensequenzen anstelle der Knotenwarteschlange. Dies ist kein klassischer BFS-Algorithmus.

Und nur zum Spaß (fast ein Jahrzehnt später) eine Antwort, die ebenfalls Generics verwendet, jedoch eine Stack- und While-Schleife enthält, basierend auf der akzeptierten Antwort von @vidstige.

public static class TypeExtentions
{

    public static IEnumerable<T> Descendants<T>(this T root, Func<T, IEnumerable<T>> selector)
    {
        var nodes = new Stack<T>(new[] { root });
        while (nodes.Any())
        {
            T node = nodes.Pop();
            yield return node;
            foreach (var n in selector(node)) nodes.Push(n);
        }
    }

    public static IEnumerable<T> Descendants<T>(this IEnumerable<T> encounter, Func<T, IEnumerable<T>> selector)
    {
        var nodes = new Stack<T>(encounter);
        while (nodes.Any())
        {
            T node = nodes.Pop();
            yield return node;
            if (selector(node) != null)
                foreach (var n in selector(node))
                    nodes.Push(n);
        }
    }
}

Bei einer Sammlung kann man diese verwenden

        var myNode = ListNodes.Descendants(x => x.Children).Where(x => x.Key == SomeKey);

oder mit einem Stammobjekt

        var myNode = root.Descendants(x => x.Children).Where(x => x.Key == SomeKey);