LINQ का उपयोग कर एक पेड़ की खोज करना

Question 1

मेरे पास इस वर्ग का एक पेड़ है।

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

मैं सभी बच्चों और उनके सभी बच्चों की तलाश करना चाहता हूं ताकि उन्हें एक शर्त मिल सके:

node.Key == SomeSpecialKey

मैं इसे कैसे लागू कर सकता हूं?

Question 2

यह एक गलत धारणा है कि इसके लिए पुनरावृत्ति की आवश्यकता है। इसके लिए एक स्टैक या एक कतार की आवश्यकता होगी और पुनरावृत्ति का उपयोग करके इसे लागू करने का सबसे आसान तरीका है। पूर्णता के लिए मैं एक गैर-पुनरावर्ती उत्तर प्रदान करूंगा।

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

उदाहरण के लिए इस अभिव्यक्ति का उपयोग करें:

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

Question 3

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

    }
}

Question 4

यदि आप Linq को syntax की तरह बनाए रखना चाहते हैं, तो आप सभी वंशज (बच्चों + बच्चों के बच्चे) को प्राप्त करने के लिए एक विधि का उपयोग कर सकते हैं।

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

यह गणना करने योग्य किसी भी अन्य का उपयोग या जहां या पहले या जो भी हो, की तरह किया जा सकता है।

Question 5

आप ट्री नोड्स को एन्यूमरेट करने के लिए इस विस्तार विधि को आजमा सकते हैं:

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

फिर एक Where()खंड के साथ इसका उपयोग करें :

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

Question 6

शायद आपको बस जरूरत है

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

या, यदि आपको एक स्तर की गहराई से खोज करने की आवश्यकता है,

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

यदि आपको सभी स्तरों पर खोज करने की आवश्यकता है, तो निम्न कार्य करें:

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

Question 7

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

और फिर आप जैसे खोज सकते हैं:

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

Question 8

IEnumerable<T>एक्सटेंशन पद्धति का उपयोग क्यों नहीं किया जाता है

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

तो बस यह करो

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

Question 9

कुछ समय पहले मैंने एक कोडप्रोजेक्ट लेख लिखा था, जो वर्णन करता है कि लाइनक को पेड़ जैसी संरचनाओं का उपयोग कैसे करें:

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

यह एक लाइन-टू-एक्सएमएल स्टाइल एपीआई प्रदान करता है जहां आप वंशज, बच्चों, पूर्वजों आदि की खोज कर सकते हैं ...

संभवतः आपकी वर्तमान समस्या के लिए overkill, लेकिन दूसरों के लिए ब्याज की हो सकती है।

Question 10

आप ट्री को क्वेरी करने के लिए इस एक्सटेंशन विधि का उपयोग कर सकते हैं।

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

Question 11

मेरे पास एक सामान्य एक्सटेंशन विधि है जो किसी भी IEnumerable<T>चपटा कर सकती है और उस चपटे संग्रह से, आप जिस नोड को चाहें प्राप्त कर सकते हैं।

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

इसका उपयोग इस तरह करें:

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

Question 12

मैं पेड़ के सामानों की गणना के लिए निम्नलिखित कार्यान्वयन का उपयोग करता हूं

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

ऊपर के कार्यान्वयन में ब्रेडफर्स्ट यूएनफोल्ड नोड्स कतार के बजाय नोड अनुक्रमों की कतार का उपयोग करता है। यह क्लासिक बीएफएस एल्गोरिथ्म तरीका नहीं है।

Question 13

और बस मज़े के लिए (लगभग एक दशक बाद) एक उत्तर भी जेनरिक का उपयोग करके लेकिन एक स्टैक और लूप के साथ, @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);
        }
    }
}

एक संग्रह को देखते हुए इस तरह का उपयोग कर सकते हैं

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

या जड़ वस्तु के साथ

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