C # 'da ağaç veri yapısı

C # bir ağaç veya grafik veri yapısı arıyordum ama sanırım sağlanan biri yok. C # 2.0 Kullanarak Veri Yapılarının Kapsamlı İncelenmesi Nedenini biraz açıklıyor. Bu işlevselliği sağlamak için yaygın olarak kullanılan uygun bir kütüphane var mı? Belki de makalede sunulan sorunları çözmek için bir strateji modeli aracılığıyla.

Kendi ArrayList'imi uyguladığım gibi, kendi ağacımı uygularken biraz aptal hissediyorum.

Sadece dengesiz olabilen jenerik bir ağaç istiyorum. Bir dizin ağacı düşünün. C5 şık görünüyor, ancak ağaç yapıları, bir düğüm hiyerarşisini temsil etmektense, arama için daha uygun dengeli kırmızı-siyah ağaçlar olarak uygulanmış gibi görünüyor.

En iyi tavsiyem, standart ağaç veri yapısının olmamasıdır, çünkü onu uygulayabilmenin birçok yolu vardır, tüm üsleri tek bir çözümle örtmek imkansızdır. Bir çözüm ne kadar spesifik olursa, verilen herhangi bir sorun için geçerli olma olasılığı o kadar az olur. LinkedList ile bile rahatsız oluyorum - dairesel bir bağlantılı liste istersem ne olur?

Uygulamanız gereken temel yapı bir düğüm koleksiyonu olacaktır ve işte başlamanız için bazı seçenekler. Diyelim ki Node sınıfı, tüm çözümün temel sınıfıdır.

Yalnızca ağaçta gezinmeniz gerekiyorsa, bir Düğüm sınıfında bir Çocuk Listesi gerekir.

Ağacın üzerinde gezinmeniz gerekiyorsa, Düğüm sınıfının üst düğümüne bir bağlantıya ihtiyacı vardır.

Bu iki noktanın tüm minutilerini ve uygulanması gereken diğer iş mantığını (çocuk sınırları, çocukları sıralamak vb.) Halleden bir AddChild yöntemi oluşturun.

delegate void TreeVisitor<T>(T nodeData);

class NTree<T>
{
    private T data;
    private LinkedList<NTree<T>> children;

    public NTree(T data)
    {
         this.data = data;
        children = new LinkedList<NTree<T>>();
    }

    public void AddChild(T data)
    {
        children.AddFirst(new NTree<T>(data));
    }

    public NTree<T> GetChild(int i)
    {
        foreach (NTree<T> n in children)
            if (--i == 0)
                return n;
        return null;
    }

    public void Traverse(NTree<T> node, TreeVisitor<T> visitor)
    {
        visitor(node.data);
        foreach (NTree<T> kid in node.children)
            Traverse(kid, visitor);
    }
}

Basit özyinelemeli uygulama ... <40 kod satırı ... Sadece sınıfın dışında ağacın köküne bir referans tutmak veya başka bir sınıfta, belki TreeNode yeniden adlandırmak gerekiyor?

Bence Aaron Gage'inkine çok benzeyen benim. Benim amacım için herhangi bir performans sorunuyla karşılaşmadım List<T>. Gerekirse bir LinkedList'e geçmek yeterince kolay olurdu.

namespace Overby.Collections
{
    public class TreeNode<T>
    {
        private readonly T _value;
        private readonly List<TreeNode<T>> _children = new List<TreeNode<T>>();

        public TreeNode(T value)
        {
            _value = value;
        }

        public TreeNode<T> this[int i]
        {
            get { return _children[i]; }
        }

        public TreeNode<T> Parent { get; private set; }

        public T Value { get { return _value; } }

        public ReadOnlyCollection<TreeNode<T>> Children
        {
            get { return _children.AsReadOnly(); }
        }

        public TreeNode<T> AddChild(T value)
        {
            var node = new TreeNode<T>(value) {Parent = this};
            _children.Add(node);
            return node;
        }

        public TreeNode<T>[] AddChildren(params T[] values)
        {
            return values.Select(AddChild).ToArray();
        }

        public bool RemoveChild(TreeNode<T> node)
        {
            return _children.Remove(node);
        }

        public void Traverse(Action<T> action)
        {
            action(Value);
            foreach (var child in _children)
                child.Traverse(action);
        }

        public IEnumerable<T> Flatten()
        {
            return new[] {Value}.Concat(_children.SelectMany(x => x.Flatten()));
        }
    }
}

Yine başka bir ağaç yapısı:

public class TreeNode<T> : IEnumerable<TreeNode<T>>
{

    public T Data { get; set; }
    public TreeNode<T> Parent { get; set; }
    public ICollection<TreeNode<T>> Children { get; set; }

    public TreeNode(T data)
    {
        this.Data = data;
        this.Children = new LinkedList<TreeNode<T>>();
    }

    public TreeNode<T> AddChild(T child)
    {
        TreeNode<T> childNode = new TreeNode<T>(child) { Parent = this };
        this.Children.Add(childNode);
        return childNode;
    }

    ... // for iterator details see below link
}

Örnek kullanım:

TreeNode<string> root = new TreeNode<string>("root");
{
    TreeNode<string> node0 = root.AddChild("node0");
    TreeNode<string> node1 = root.AddChild("node1");
    TreeNode<string> node2 = root.AddChild("node2");
    {
        TreeNode<string> node20 = node2.AddChild(null);
        TreeNode<string> node21 = node2.AddChild("node21");
        {
            TreeNode<string> node210 = node21.AddChild("node210");
            TreeNode<string> node211 = node21.AddChild("node211");
        }
    }
    TreeNode<string> node3 = root.AddChild("node3");
    {
        TreeNode<string> node30 = node3.AddChild("node30");
    }
}

BONUS
Tam teşekküllü ağaca bakın:

• yineleyici
• Aranıyor
• Java / C #

https://github.com/gt4dev/yet-another-tree-structure

Genel olarak mükemmel C5 Genel Koleksiyon Kütüphanesi , setler, çantalar ve sözlükler dahil olmak üzere birkaç farklı ağaç tabanlı veri yapısına sahiptir. Uygulama ayrıntılarını incelemek istiyorsanız kaynak kodu kullanılabilir. (C5 koleksiyonlarını iyi sonuçlarla üretim kodunda kullandım, ancak özellikle ağaç yapılarını kullanmadım.)

Bkz. Http://quickgraph.codeplex.com/

QuickGraph .Net 2.0 ve üstü için genel yönlendirilmiş / yönlendirilmemiş grafik veri yapıları ve algoritmalar sağlar. QuickGraph, önce derinlik arama, ilk nefes arama, A * arama, en kısa yol, k-en kısa yol, maksimum akış, minimum yayılan ağaç, en az yaygın atalar gibi algoritmalar ile birlikte gelir ... QuickGraph MSAGL, GLEE ve Graphviz'i destekler grafikleri renderleme, GraphML'e serileştirme, vb ...

Kendi yazınızı yazmak isterseniz, C # 2.0 veri yapılarının etkin kullanımını ve C # 'daki veri yapılarının uygulamanızı nasıl analiz edeceğinizi ayrıntılarıyla anlatan bu altı bölümlü belgeyle başlayabilirsiniz. Her makalede örnekler ve takip edebileceğiniz örnekler içeren bir yükleyici vardır.

“C # 2.0 Kullanarak Veri Yapılarının Kapsamlı Bir İncelenmesi” Scott Mitchell

Çözümlere küçük bir uzantım var.

Özyinelemeli genel bildirim ve türetici bir alt sınıf kullanarak, gerçek hedefinize daha iyi konsantre olabilirsiniz.

Dikkat edin, genel olmayan bir uygulamadan farklıdır, 'NodeWorker'da' düğüm 'atmanız gerekmez.

İşte benim örnek:

public class GenericTree<T> where T : GenericTree<T> // recursive constraint  
{
  // no specific data declaration  

  protected List<T> children;

  public GenericTree()
  {
    this.children = new List<T>();
  }

  public virtual void AddChild(T newChild)
  {
    this.children.Add(newChild);
  }

  public void Traverse(Action<int, T> visitor)
  {
    this.traverse(0, visitor);
  }

  protected virtual void traverse(int depth, Action<int, T> visitor)
  {
    visitor(depth, (T)this);
    foreach (T child in this.children)
      child.traverse(depth + 1, visitor);
  }
}

public class GenericTreeNext : GenericTree<GenericTreeNext> // concrete derivation
{
  public string Name {get; set;} // user-data example

  public GenericTreeNext(string name)
  {
    this.Name = name;
  }
}

static void Main(string[] args)  
{  
  GenericTreeNext tree = new GenericTreeNext("Main-Harry");  
  tree.AddChild(new GenericTreeNext("Main-Sub-Willy"));  
  GenericTreeNext inter = new GenericTreeNext("Main-Inter-Willy");  
  inter.AddChild(new GenericTreeNext("Inter-Sub-Tom"));  
  inter.AddChild(new GenericTreeNext("Inter-Sub-Magda"));  
  tree.AddChild(inter);  
  tree.AddChild(new GenericTreeNext("Main-Sub-Chantal"));  
  tree.Traverse(NodeWorker);  
}  

static void NodeWorker(int depth, GenericTreeNext node)  
{                                // a little one-line string-concatenation (n-times)
  Console.WriteLine("{0}{1}: {2}", String.Join("   ", new string[depth + 1]), depth, node.Name);  
}  

İşte benim:

class Program
{
    static void Main(string[] args)
    {
        var tree = new Tree<string>()
            .Begin("Fastfood")
                .Begin("Pizza")
                    .Add("Margherita")
                    .Add("Marinara")
                .End()
                .Begin("Burger")
                    .Add("Cheese burger")
                    .Add("Chili burger")
                    .Add("Rice burger")
                .End()
            .End();

        tree.Nodes.ForEach(p => PrintNode(p, 0));
        Console.ReadKey();
    }

    static void PrintNode<T>(TreeNode<T> node, int level)
    {
        Console.WriteLine("{0}{1}", new string(' ', level * 3), node.Value);
        level++;
        node.Children.ForEach(p => PrintNode(p, level));
    }
}

public class Tree<T>
{
    private Stack<TreeNode<T>> m_Stack = new Stack<TreeNode<T>>();

    public List<TreeNode<T>> Nodes { get; } = new List<TreeNode<T>>();

    public Tree<T> Begin(T val)
    {
        if (m_Stack.Count == 0)
        {
            var node = new TreeNode<T>(val, null);
            Nodes.Add(node);
            m_Stack.Push(node);
        }
        else
        {
            var node = m_Stack.Peek().Add(val);
            m_Stack.Push(node);
        }

        return this;
    }

    public Tree<T> Add(T val)
    {
        m_Stack.Peek().Add(val);
        return this;
    }

    public Tree<T> End()
    {
        m_Stack.Pop();
        return this;
    }
}

public class TreeNode<T>
{
    public T Value { get; }
    public TreeNode<T> Parent { get; }
    public List<TreeNode<T>> Children { get; }

    public TreeNode(T val, TreeNode<T> parent)
    {
        Value = val;
        Parent = parent;
        Children = new List<TreeNode<T>>();
    }

    public TreeNode<T> Add(T val)
    {
        var node = new TreeNode<T>(val, this);
        Children.Add(node);
        return node;
    }
}

Çıktı:

Fastfood
   Pizza
      Margherita
      Marinara
   Burger
      Cheese burger
      Chili burger
      Rice burger

Bu basit örneği deneyin.

public class TreeNode<TValue>
{
    #region Properties
    public TValue Value { get; set; }
    public List<TreeNode<TValue>> Children { get; private set; }
    public bool HasChild { get { return Children.Any(); } }
    #endregion
    #region Constructor
    public TreeNode()
    {
        this.Children = new List<TreeNode<TValue>>();
    }
    public TreeNode(TValue value)
        : this()
    {
        this.Value = value;
    }
    #endregion
    #region Methods
    public void AddChild(TreeNode<TValue> treeNode)
    {
        Children.Add(treeNode);
    }
    public void AddChild(TValue value)
    {
        var treeNode = new TreeNode<TValue>(value);
        AddChild(treeNode);
    }
    #endregion
}

Diğer insanlar için yararlı olabilecek bir Node sınıfı oluşturuyorum . Sınıf aşağıdaki özelliklere sahiptir:

• çocuklar
• Atalar
• Torunları
• Kardeşler
• Düğüm seviyesi
• ebeveyn
• Kök
• Vb.

Ayrıca, Id ve ParentId içeren düz bir öğe listesini ağaca dönüştürme imkanı da vardır. Düğümler hem çocuklara hem de ebeveyne referans verir, böylece yineleme düğümlerini oldukça hızlı hale getirir.

Çünkü şimdi yayımlanan .net kod tabanı dikkat çekmek istiyorum: özellikle SortedSetbir Red-Black-Tree uygulayan bir kod :

https://github.com/Microsoft/referencesource/blob/master/System/compmod/system/collections/generic/sortedset.cs

Ancak bu dengeli bir ağaç yapısıdır. Bu yüzden cevabım, .net çekirdek kütüphanesindeki tek yerli ağaç yapısı olduğuna inandığım şeye daha çok bir referans.

@Berezh tarafından paylaşılan kodu tamamladım.

  public class TreeNode<T> : IEnumerable<TreeNode<T>>
    {

        public T Data { get; set; }
        public TreeNode<T> Parent { get; set; }
        public ICollection<TreeNode<T>> Children { get; set; }

        public TreeNode(T data)
        {
            this.Data = data;
            this.Children = new LinkedList<TreeNode<T>>();
        }

        public TreeNode<T> AddChild(T child)
        {
            TreeNode<T> childNode = new TreeNode<T>(child) { Parent = this };
            this.Children.Add(childNode);
            return childNode;
        }

        public IEnumerator<TreeNode<T>> GetEnumerator()
        {
            throw new NotImplementedException();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return (IEnumerator)GetEnumerator();
        }
    }
    public class TreeNodeEnum<T> : IEnumerator<TreeNode<T>>
    {

        int position = -1;
        public List<TreeNode<T>> Nodes { get; set; }

        public TreeNode<T> Current
        {
            get
            {
                try
                {
                    return Nodes[position];
                }
                catch (IndexOutOfRangeException)
                {
                    throw new InvalidOperationException();
                }
            }
        }


        object IEnumerator.Current
        {
            get
            {
                return Current;
            }
        }


        public TreeNodeEnum(List<TreeNode<T>> nodes)
        {
            Nodes = nodes;
        }

        public void Dispose()
        {
        }

        public bool MoveNext()
        {
            position++;
            return (position < Nodes.Count);
        }

        public void Reset()
        {
            position = -1;
        }
    }

İşte bir ağaç

public class Tree<T> : List<Tree<T>>
{
    public  T Data { get; private set; }

    public Tree(T data)
    {
        this.Data = data;
    }

    public Tree<T> Add(T data)
    {
        var node = new Tree<T>(data);
        this.Add(node);
        return node;
    }
}

Başlatıcıları bile kullanabilirsiniz:

    var tree = new Tree<string>("root")
    {
        new Tree<string>("sample")
        {
            "console1"
        }
    };

Çoğu ağaç işlediğiniz verilerden oluşur.

Diyelim ki personbirinin ayrıntılarını içeren bir sınıfınız var parents, “etki alanı sınıfınızın” bir parçası olarak ağaç yapısını mı tercih edersiniz yoksa kişi nesnelerinize bağlantılar içeren ayrı bir ağaç sınıfı mı kullanırsınız? Bütün alma gibi basit bir işlemle düşünün grandchildrena person, bu kod olmalıdır person sınıf veya kullanıcı gerektiği personsınıfında ayrı bir ağaç sınıfına hakkında bilmek var?

Başka bir örnek derleyicide bir ayrıştırma ağacı ...

Bu örneklerin her ikisinin de gösterdiği şey, bir ağaç kavramının verilerin etki alanının bir parçası olması ve ayrı bir genel amaçlı ağaç kullanılması, en az oluşturulan nesnelerin sayısını iki katına çıkarmanın yanı sıra API'yi tekrar programlamayı zorlaştırmaktadır.

İstediğimiz şey, standart ağaç işlemlerini kullanmak zorunda kalmadan standart ağaç işlemlerini tüm ağaçlar için yeniden uygulamak zorunda kalmadan yeniden kullanmanın bir yoludur. Boost, C ++ için bu tür bir sorunu çözmeye çalıştı, ancak henüz .NET için herhangi bir etki görmedim.

Komple çözüm ve yukarıdaki NTree sınıfı kullanarak örnek ekledim, "AddChild" yöntemi de eklendi ...

    public class NTree<T>
    {
        public T data;
        public LinkedList<NTree<T>> children;

        public NTree(T data)
        {
            this.data = data;
            children = new LinkedList<NTree<T>>();
        }

        public void AddChild(T data)
        {
            var node = new NTree<T>(data) { Parent = this };
            children.AddFirst(node);
        }

        public NTree<T> Parent { get; private set; }

        public NTree<T> GetChild(int i)
        {
            foreach (NTree<T> n in children)
                if (--i == 0)
                    return n;
            return null;
        }

        public void Traverse(NTree<T> node, TreeVisitor<T> visitor, string t, ref NTree<T> r)
        {
            visitor(node.data, node, t, ref r);
            foreach (NTree<T> kid in node.children)
                Traverse(kid, visitor, t, ref r);
        }
    }
    public static void DelegateMethod(KeyValuePair<string, string> data, NTree<KeyValuePair<string, string>> node, string t, ref NTree<KeyValuePair<string, string>> r)
    {
        string a = string.Empty;
        if (node.data.Key == t)
        {
            r = node;
            return;
        }
    }

kullanma

 NTree<KeyValuePair<string, string>> ret = null;
 tree.Traverse(tree, DelegateMethod, node["categoryId"].InnerText, ref ret);

İşte benim BST uygulaması

class BST
{
    public class Node
    {
        public Node Left { get; set; }
        public object Data { get; set; }
        public Node Right { get; set; }

        public Node()
        {
            Data = null;
        }

        public Node(int Data)
        {
            this.Data = (object)Data;
        }

        public void Insert(int Data)
        {
            if (this.Data == null)
            {
                this.Data = (object)Data;
                return;
            }
            if (Data > (int)this.Data)
            {
                if (this.Right == null)
                {
                    this.Right = new Node(Data);
                }
                else
                {
                    this.Right.Insert(Data);
                }
            }
            if (Data <= (int)this.Data)
            {
                if (this.Left == null)
                {
                    this.Left = new Node(Data);
                }
                else
                {
                    this.Left.Insert(Data);
                }
            }
        }

        public void TraverseInOrder()
        {
            if(this.Left != null)
                this.Left.TraverseInOrder();
            Console.Write("{0} ", this.Data);
            if (this.Right != null)
                this.Right.TraverseInOrder();
        }
    }

    public Node Root { get; set; }
    public BST()
    {
        Root = new Node();
    }
}

Bu ağacı GUI'de görüntüleyecekseniz, TreeView ve TreeNode'u kullanabilirsiniz . (Teknik olarak bir GUI'ye koymadan bir TreeNode oluşturabileceğinizi varsayalım, ancak basit bir ev yapımı TreeNode uygulamasından daha fazla yükü var.)

Daha az bellek kullanan bir köklü ağaç veri yapısı uygulamasına ihtiyacınız varsa, Node sınıfınızı aşağıdaki gibi yazabilirsiniz (C ++ uygulaması):

class Node {
       Node* parent;
       int item; // depending on your needs

       Node* firstChild; //pointer to left most child of node
       Node* nextSibling; //pointer to the sibling to the right
}