C＃のツリーデータ構造
C＃でツリーまたはグラフのデータ構造を探していましたが、提供されていないと思います。 C＃2.0を使ったデータ構造の徹底的な検証 理由を少し説明します。この機能を提供するために一般的に使用されている便利なライブラリはありますか？おそらく記事で提示されている問題を解決するための戦略パターンを通して。
自分のArrayListを実装するのと同じように、私は自分のツリーを少し愚かに実装しているように感じます。
私はただバランスを崩すことができるジェネリックツリーが欲しいのです。ディレクトリツリーを考えてください。 C5は気の利いた外観をしていますが、それらのツリー構造はノードの階層を表すよりも検索に適しているバランスの取れた赤黒ツリーとして実装されているようです。
これを実装する方法はたくさんあり、1つのソリューションですべての基底をカバーすることは不可能なので、標準のツリーデータ構造は存在しないことをお勧めします。より具体的な解決策は、与えられた問題に適用できる可能性が低くなります。 LinkedListに悩まされることさえあります - 循環リンクリストが欲しいのですが？
実装する必要がある基本的な構造はノードの集まりです。ここから始めるためのいくつかのオプションがあります。 Nodeクラスがソリューション全体の基底クラスであるとしましょう。
ツリーを下に移動するだけの場合は、Nodeクラスに子のリストが必要です。
ツリーを上に移動する必要がある場合は、Nodeクラスにその親ノードへのリンクが必要です。
これら2点のすべての細かい点と、実装する必要があるその他のビジネスロジック（子の制限、子の並べ替えなど）を処理するAddChildメソッドを構築します。
私はそれを認めたくありませんが、結局私はリンクリストを使って私自身のツリークラスを書くことになりました。無関係なメモで私はちょうど私が「車軸」と呼んでいるものに添付されたとき商品のより容易な輸送を可能にするこの丸いものを発見しました。
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);
}
}
単純な再帰的な実装... <40行のコード...クラスの外側のツリーのルートへの参照を保持するか、別のクラスでラップする必要があります。おそらくTreeNodeに名前を変更します。
これが私の意見ですが、これは Aaron Gage's に非常によく似ています。私の目的のために、私はList<T>に関する性能問題に遭遇しませんでした。必要に応じてLinkedListに切り替えるのは簡単です。
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()));
}
}
}
さらに別の木構造：
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
}
使用例
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");
}
}
ボーナス
本格的な木を見てください。
- イテレータ
- 検索する
- Java/C＃
一般的に優れた C5 Generic Collection Library は、セット、バッグ、辞書など、ツリーベースのデータ構造がいくつかあります。実装の詳細を調べたい場合は、ソースコードが利用可能です。 （本番コードでC5コレクションを使用したところ良好な結果が得られましたが、特にツリー構造は使用していません）。
http://quickgraph.codeplex.com/ を参照してください。
QuickGraphは、.NET 2.0以上用の一般的な有向/無向グラフデータ構造とアルゴリズムを提供します。 QuickGraphには、深さ優先検索、呼吸優先検索、A *検索、最短パス、k最短パス、最大フロー、最小全域木、最小公約数などのアルゴリズムが付属しています。グラフのレンダリング、GraphMLへのシリアル化など.
あなたがあなた自身のものを書きたいのであれば、あなたはC＃2.0データ構造の効果的な使い方とC＃でのデータ構造の実装を分析することをどのように進めるかを詳述するこの6部のドキュメントから始めることができます。各記事には、一緒に従うことができるサンプルとサンプルとインストーラーがあります。
“ C＃2.0を使ったデータ構造の広範な検査” by Scott Mitchell
私は解決策を少し拡張しました。
再帰的総称宣言と派生サブクラスを使用すると、実際のターゲットに集中することができます。
注意してください、それは非一般的な実装とは異なり、あなたは 'NodeWorker'に 'node'をキャストする必要はありません。
これが私の例です：
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);
}
この簡単なサンプルを試してください。
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
}
私は Node class を作成しました。これは他の人にとって役に立つことでしょう。このクラスには、次のようなプロパティがあります。
- 子供
- 祖先
- 子孫
- きょうだい
- ノードのレベル
- 親
- Root
- 等。
IdとParentIdを持つ項目のフラットリストをツリーに変換することもできます。ノードは子と親の両方への参照を保持しているので、ノードの反復はかなり速くなります。
言及されていないので、今リリースされている.net code-base：特にRed-Black-Treeを実装するSortedSetのコードに注目してください。
しかし、これはバランスの取れたツリー構造です。だから私の答えは私が信じるものへのより多くの参照です。netコアライブラリ内の唯一のネイティブツリー構造。
これが木です
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;
}
}
イニシャライザを使うこともできます。
var tree = new Tree<string>("root")
{
new Tree<string>("sample")
{
"console1"
}
};
これが私自身のものです：
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;
}
}
出力：
Fastfood
Pizza
Margherita
Marinara
Burger
Cheese burger
Chili burger
Rice burger
@Berezhが共有しているコードを完成させました。
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;
}
}
ほとんどの木はあなたが処理しているデータによって形成されます。
誰かの
personの詳細を含むparentsクラスがあるとしましょう。「ドメインクラス」の一部としてツリー構造を使用するのか、それともあなたの人物オブジェクトへのリンクを含む別のツリークラスを使用するのですか。grandchildrenのすべてのpersonを取得するような単純な操作を考えてください。このコードはpersonクラスにあるべきですか、それともpersonクラスのユーザーは別のツリークラスを知る必要があるべきですか？
もう一つの例は、コンパイラの解析木です…
これら両方の例が示すのは、ツリーの概念がデータのdomainの一部であり、別の汎用ツリーを使用すると、作成されるオブジェクトの数が少なくとも2倍になることです。 APIは再度プログラムするのが困難です。
私たちが欲しいのは、標準ツリークラスを使用する必要はなく、同時にすべてのツリーに対してそれらを再実装する必要なしに、標準ツリー操作を再利用する方法です。 BoostはC++でこの種の問題を解決しようとしましたが、.NETへの影響が適応されることはまだわかりません。
私は上記のNTreeクラスを使用して完全なソリューションと例を追加しました、また「AddChild」メソッドを追加しました...
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;
}
}
使う
NTree<KeyValuePair<string, string>> ret = null;
tree.Traverse(tree, DelegateMethod, node["categoryId"].InnerText, ref ret);