Question

鉴于以下类别：

public class Parent {
    public Parent() 
    {
        children = new List<Child>();
    }

    public Guid Id { get; set; }
    public ICollection<Child> children { get; set; }
}

public class Child {
    public Guid Id { get; set; }
    public Guid ParentId { get; set; }
}

以下数据：

List<Parent> allParents = new List<Parent>() { /* ... */ };
List<Child> allChildren = new List<Child>() { /* ... */ };

如何有效地将Child中的每个allChildren合并到Parent内的allParents内？

我能想到的唯一解决方案感觉非常低效：

foreach (var child in allChildren)
{
    allParents.Where(p => p.Id == child.ParentId).Single().Children.Add(child);
}

修改想到另一种解决方案：

var parents = listOfAllParents();
var allParents = new List<Parent>();
foreach (var parent in parents) {
    parent.children = allChildren.Where(c => parent.Id == c.ParentId).ToList();
    allParents.Add(parent);
}

由于数据由ParentId ...

编制索引，因此可能更容易改进

Answer 1

基本上有两种有效的方法，包括准备基于快速哈希的查找数据结构，然后用它来链接项目。

使用Dictionary<Guid, Parent>按子女ParentId查找父母：

var parentById = allParents.ToDictionary(parent => parent.Id);
foreach (var child in allChildren)
{
    var parent = parentById[child.ParentId];
    parent.children.Add(child);
}

使用ILoookup<Guid, Child>按父母Id查找子女：

var childrenByParentId = allChildren.ToLookup(child => child.ParentId);
foreach (var parent in allParents)
{
    foreach (var child in childrenByParentId[parent.Id])
    {
        parent.children.Add(child);
    }
}

两种解决方案都具有线性时间复杂度。

填充一组列表

1 个答案: