লিনকিউ ব্যবহার করে একটি গাছ অনুসন্ধান করা

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

লিনকের সাথে অবজেক্টের একটি গাছ অনুসন্ধান করা হচ্ছে

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

যদি আপনি সিনট্যাক্সের মতো লিনক বজায় রাখতে চান তবে আপনি সমস্ত বংশধরদের (শিশু + শিশুদের ইত্যাদি) পাওয়ার জন্য একটি পদ্ধতি ব্যবহার করতে পারেন

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

এটি একটি লিনাক-টু-এক্সএমএল স্টাইল এপিআই সরবরাহ করে যেখানে আপনি বংশধর, শিশু, পূর্বপুরুষ ইত্যাদি অনুসন্ধান করতে পারেন ...

আপনার বর্তমান সমস্যার জন্য সম্ভবত ওভারকিল, তবে অন্যের পক্ষে এটি আগ্রহী হতে পারে।

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

উপরের প্রয়োগে BreadthFirstUnfold নোড সারির পরিবর্তে নোড সিক্যুয়েন্সের সারি ব্যবহার করে। এটি ক্লাসিক বিএফএস অ্যালগরিদম উপায় নয়।

Question 13

এবং কেবল মজাদার জন্য (প্রায় এক দশক পরে) জেনারিকস ব্যবহার করে তবে একটি স্ট্যাক এবং যখন লুপ সহ একটি উত্তর, উত্তরটি @ বিডিস্টিজ দ্বারা গৃহীত উত্তরের ভিত্তিতে তৈরি করা হয়েছে।

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