アイテムのリストをツリーに変換する素敵で普遍的な方法
カテゴリのリストがあります：
╔════╦═════════════╦═════════════╗
║ Id ║ Name ║ Parent_id ║
╠════╬═════════════╬═════════════╣
║ 1 ║ Sports ║ 0 ║
║ 2 ║ Balls ║ 1 ║
║ 3 ║ Shoes ║ 1 ║
║ 4 ║ Electronics ║ 0 ║
║ 5 ║ Cameras ║ 4 ║
║ 6 ║ Lenses ║ 5 ║
║ 7 ║ Tripod ║ 5 ║
║ 8 ║ Computers ║ 4 ║
║ 9 ║ Laptops ║ 8 ║
║ 10 ║ Empty ║ 0 ║
║ -1 ║ Broken ║ 999 ║
╚════╩═════════════╩═════════════╝
各カテゴリには親があります。親が0の場合-それはルートカテゴリであることを意味します。
以下のようなツリー構造に変換するための最も良い方法とは何ですか？
つまり、この構造からデータを取得する方法：
class category
{
public int Id;
public int ParentId;
public string Name;
}
これに：
class category
{
public int Id;
public int ParentId;
public string Name;
public List<Category> Subcategories;
}
普遍的な方法で？ //ユニバーサルは、言及されたクラスだけではありません。
スマートなアイデアはありますか？ ;）
データ：
var categories = new List<category>() {
new category(1, "Sport", 0),
new category(2, "Balls", 1),
new category(3, "Shoes", 1),
new category(4, "Electronics", 0),
new category(5, "Cameras", 4),
new category(6, "Lenses", 5),
new category(7, "Tripod", 5),
new category(8, "Computers", 4),
new category(9, "Laptops", 8),
new category(10, "Empty", 0),
new category(-1, "Broken", 999),
};
niversalメソッドが必要な場合は、追加のクラスが必要です：
public class TreeItem<T>
{
public T Item { get; set; }
public IEnumerable<TreeItem<T>> Children { get; set; }
}
次に、このヘルパーで使用します：
internal static class GenericHelpers
{
/// <summary>
/// Generates tree of items from item list
/// </summary>
///
/// <typeparam name="T">Type of item in collection</typeparam>
/// <typeparam name="K">Type of parent_id</typeparam>
///
/// <param name="collection">Collection of items</param>
/// <param name="id_selector">Function extracting item's id</param>
/// <param name="parent_id_selector">Function extracting item's parent_id</param>
/// <param name="root_id">Root element id</param>
///
/// <returns>Tree of items</returns>
public static IEnumerable<TreeItem<T>> GenerateTree<T, K>(
this IEnumerable<T> collection,
Func<T, K> id_selector,
Func<T, K> parent_id_selector,
K root_id = default(K))
{
foreach (var c in collection.Where(c => parent_id_selector(c).Equals(root_id)))
{
yield return new TreeItem<T>
{
Item = c,
Children = collection.GenerateTree(id_selector, parent_id_selector, id_selector(c))
};
}
}
}
使用法：
var root = categories.GenerateTree(c => c.Id, c => c.ParentId);
テスト：
static void Test(IEnumerable<TreeItem<category>> categories, int deep = 0)
{
foreach (var c in categories)
{
Console.WriteLine(new String('\t', deep) + c.Item.Name);
Test(c.Children, deep + 1);
}
}
// ...
Test(root);
出力
Sport
Balls
Shoes
Electronics
Cameras
Lenses
Tripod
Computers
Laptops
Empty
_foreach (var cat in categories)
{
cat.Subcategories = categories.Where(child => child.ParentId == cat.Id)
.ToList();
}
_O(n*n)の複雑さが得られます。
より最適化された方法は、ルックアップテーブルを使用することです。
_var childsHash = categories.ToLookup(cat => cat.ParentId);
foreach (var cat in categories)
{
cat.Subcategories = childsHash[cat.Id].ToList();
}
_O(2*n)≈O(n)が得られます
その結果、次の構造が得られます（LinqPadから表示）。
親を識別する方法を渡すさらに別の方法。完全なコード（ITreeおよびxUnitテストの内部実装を含む）はGistとして利用できます： ツリーへのアイテム
使用法：
ITree<Category> tree = categories.ToTree((parent, child) => child.ParentId == parent.Id);
生産物：
<ROOT>
-Sports
--Balls
--Shoes
-Electronics
--Cameras
---Lenses
---Tripod
--Computers
---Laptops
-Empty
-Broken
ユニバーサルツリーノードインターフェイス：
public interface ITree<T>
{
T Data { get; }
ITree<T> Parent { get; }
ICollection<ITree<T>> Children { get; }
bool IsRoot { get; }
bool IsLeaf { get; }
int Level { get; }
}
コレクションの拡張方法：
public static ITree<T> ToTree<T>(this IList<T> items, Func<T, T, bool> parentSelector)
{
if (items == null) throw new ArgumentNullException(nameof(items));
var lookup = items.ToLookup(
item => items.FirstOrDefault(parent => parentSelector(parent, item)),
child => child);
return Tree<T>.FromLookup(lookup);
}
以下のデータベースクエリを使用して、親子関係を持つカテゴリのリストを取得できます。
WITH tree (categoryId, parentId, level, categoryName, rn) as
(
SELECT categoryId, parentid, 0 as level, categoryName,
convert(varchar(max),right(row_number() over (order by categoryId),10)) rn
FROM Categories
WHERE parentid = 0
UNION ALL
SELECT c2.categoryId, c2.parentid, tree.level + 1, c2.categoryName,
rn + '/' + convert(varchar(max),right(row_number() over
(order by tree.categoryId),10))
FROM Categories c2
INNER JOIN tree ON tree.categoryId = c2.parentid
)
SELECT *
FROM tree
order by RN
これがあなたのお役に立てば幸いです。
ここに私がホイップした小さな例があります。かなり「ジェネリック」です。
インターフェイスを定義することで汎用的なアプローチをとることもできます（これにより、関数の引数を簡略化できます）-しかし、私はそうしないことを選択しました。いずれの場合でも、「マッパー」およびセレクター関数により、異なるタイプで機能することができます。
また、これはnotは非常に効率的な実装であることに注意してください（すべてのサブツリーで考えられるすべての子を保持し、繰り返し繰り返します）が、特定のタスクに適している場合があります。過去に、私はDictionary<key,collection>アプローチも使用しました。これにはより良い境界がありますが、そのように書く気はありませんでした:)
これは「LINQPad C＃プログラム」として実行されます。楽しい！
// F - flat type
// H - hiearchial type
IEnumerable<H> MakeHierarchy<F,H>(
// Remaining items to process
IEnumerable<F> flat,
// Current "parent" to look for
object parentKey,
// Find key for given F-type
Func<F,object> key,
// Convert between types
Func<F,IEnumerable<H>,H> mapper,
// Should this be added as immediate child?
Func<F,object,bool> isImmediateChild) {
var remainder = flat.Where(f => !isImmediateChild(f, parentKey))
.ToList();
return flat
.Where(f => isImmediateChild(f, parentKey))
.Select(f => {
var children = MakeHierarchy(remainder, key(f), key, mapper, isImmediateChild);
return mapper(f, children);
});
}
class category1
{
public int Id;
public int ParentId;
public string Name;
public category1(int id, string name, int parentId) {
Id = id;
Name = name;
ParentId = parentId;
}
};
class category2
{
public int Id;
public int ParentId;
public string Name;
public IEnumerable<category2> Subcategories;
};
List<category1> categories = new List<category1>() {
new category1(1, "Sport", 0),
new category1(2, "Balls", 1),
new category1(3, "Shoes", 1),
new category1(4, "Electronics", 0),
new category1(5, "Cameras", 4),
new category1(6, "Lenses", 5),
new category1(7, "Tripod", 5),
new category1(8, "Computers", 4),
new category1(9, "Laptops", 8),
new category1(10, "Empty", 0),
new category1(-1, "Broken", 999),
};
object KeyForCategory (category1 c1) {
return c1.Id;
}
category2 MapCategories (category1 c1, IEnumerable<category2> subs) {
return new category2 {
Id = c1.Id,
Name = c1.Name,
ParentId = c1.ParentId,
Subcategories = subs,
};
}
bool IsImmediateChild (category1 c1, object id) {
return c1.ParentId.Equals(id);
}
void Main()
{
var h = MakeHierarchy<category1,category2>(categories, 0,
// These make it "Generic". You can use lambdas or whatever;
// here I am using method groups.
KeyForCategory, MapCategories, IsImmediateChild);
h.Dump();
}
Ilya Ivanov algorithm（上記参照）を使用して、メソッドをより汎用的にしました。
public static IEnumerable<TJ> GenerateTree<T, TK, TJ>(this IEnumerable<T> items,
Func<T, TK> idSelector,
Func<T, TK> parentSelector,
Func<T, IEnumerable<T>, TJ> outSelector)
{
IList<T> mlist = items.ToList();
ILookup<TK, T> mcl = mlist.ToLookup(parentSelector);
return mlist.Select(cat => outSelector(cat, mcl[idSelector(cat)]));
}
使用法 ：
IEnumerable<Category> mlc = GenerateTree(categories,
c => c.Id,
c => c.ParentId,
(c, ci) => new Category
{
Id = c.Id,
Name = c.Name,
ParentId = c.ParentId ,
Subcategories = ci
});