将平面列表映射到具有父 ID 的分层列表 C#

Question

我有一个简单的类别列表，如以下类所示

public class FlatCategoryList
{
    public List<FlatCategory> Categories { get; set; }
}
public class FlatCategory
{
    public string ID { get; set; }
    public string Name { get; set; }
    public string ParentID { get; set; }
}

我正在尝试将我的平面类别列表映射到如下所示的层级结构：

public class HieraricalCategoryList
{
    public List<Category> Categories { get; set; }
}
public class Category
{
    public string ID { get; set; }
    public string Name { get; set; }
    public string ParentID { get; set; }

    public List<Category> ChildCategories { get; set; }
}

我的问题是，鉴于可能存在无限数量的子层，实现这一目标的最佳方法是什么？

public HieraricalCategoryList MapCategories(FlatCategoryList flatCategoryList)
{
    var hieraricalCategoryList = new HieraricalCategoryList();

    //Do something here to map the flat category list to the hierarichal one...

    return hieraricalCategoryList;
}

Answer 1

public HieraricalCategoryList MapCategories(FlatCategoryList flatCategoryList)
{
    var categories = (from fc in flatCategoryList.Categories
                      select new Category() {
                          ID = fc.ID,
                          Name = fc.Name,
                          ParentID = fc.ParentID
                      }).ToList();

    var lookup = categories.ToLookup(c => c.ParentID);

    foreach(var c in categories)
    {
        // you can skip the check if you want an empty list instead of null
        // when there is no children
        if(lookup.Contains(c.ID))
            c.ChildCategories = lookup[c.ID].ToList();
    }

    return new HieraricalCategoryList() { Categories = categories };
}

Answer 2

进行这种转换的一种非常简单且高性能的方法是创建一个查找，在该查找中您将 ID 值映射到应该是该 ID 值的子节点的节点。可以在节点的单遍中创建此查找。之后，您可以再次遍历所有节点，将它们的子集合分配为查找中它们的 ID 值的值。

请注意，如果查找映射到您要转换的类型的对象，而不是从其转换，这会更简单。

var lookup = list.Categories
    .Select(category => new Category()
    {
        ID = category.ID,
        Name = category.Name,
        ParentID = category.ParentID,
    })
    .ToLookup(category => category.ParentID);

foreach (var category in lookup.SelectMany(x => x))
    category.ChildCategories = lookup[category.ID].ToList();

var newList = new HieraricalCategoryList()
{
    Categories = lookup[null].ToList(),
};

Answer 3

改进了建议的答案

public HieraricalCategoryList MapCategories(FlatCategoryList flatCategoryList)
{
    var categories = (from fc in flatCategoryList.Categories
                      select new Category() {
                          ID = fc.ID,
                          Name = fc.Name,
                          ParentID = fc.ParentID
                      }).ToList();

    var lookup = categories.ToLookup(c => c.ParentID);

    foreach(var c in rootCategories)//only loop through root categories
    {
        // you can skip the check if you want an empty list instead of null
        // when there is no children
        if(lookup.Contains(c.ID))
            c.ChildCategories = lookup[c.ID].ToList();
    }

    //if you want to return only root categories not all the flat list
    //with mapped child 

    categories.RemoveAll(c => c.ParentId != 0);//put what ever your parent id is

    return new HieraricalCategoryList() { Categories = categories };
}

Answer 4

使用两遍解决方案。这假设完整的集合可以放入内存。第一遍扫描平面类别列表，并构建一个类别字典，由 ID 索引。此时子集合全部为空，父属性为空。然后第二遍再次扫描它们，构建子集合并设置父属性。

未经测试的代码：

var final = new Dictionary<string, Category>();
var rootCategories = new List<Category>();

// Pass 1
foreach (var flat in flatList)
{
  Category cat = new Category() { ID = flat.ID, Name = flat.Name, parent = null }
  cat.Children = new List<Category>();
  final[flat.ID] = cat;
}

// Pass 2
foreach (var flat in flatList)
{
  // find myself -- must exist
  var self = final[flat.ID];

  // find parent -- may not exist
  if (final.ContainsKey(flat.ParentID)
  {
    var parent = final[flat.ParentID];
    parent.Children.Add(self);
    self.Parent = parent;     
  }
  else
  {
    rootCategories.Add(self);
  }

}

这将有 O(n) 的运行时间，因为它是两个线性扫描，以及一些字典查找，它们是 O(1)。