如何在 C# 中的分层列表父级下查找子级总数和大子级数

Question

我的项目中有一个树形菜单。

数据如下所示

{ParentId = null, Id = 10, Name "a"}, 
{ParentId = null, Id = 33, Name "aa"}, 
{ParentId = 10 , Id = 11, Name "aaa"}, 
{ParentId = 10, Id = 12, Name "aaaa"}, 
{ParentId = 11, Id = 13, Name "aaaaa"}, 
{ParentId = 56 ,Id = 14, Name "aas"}, 
{ParentId = 78 , Id = 15, Name "adss"}, 
{ParentId = 99 , Id = 16, Name "ader"}

我创建了一个分层列表来保存数据

public class NavBarItem
    {
        public int? Id { get; set; }
        public int? ParentId { get; set; }
        public string Name{get;set;}
        public IEnumerable<NavBarItem> Children { get; set; }
        public int ChildCount { get; set; }
        public int HierarchyLevel { get; set; }
    }

我的递归方法将从表中获取数据并将其绑定到分层列表

我想在这里得到的是每个父母的子女/孙子女总数。

例如，父 A 有子 B，子 B 有子 C & D，则 A 的总 ChildCount 应为 3，B 应为 2，C 应为 0

我还想在每个父母中获得层次结构级别。

在上面的示例中：父母 A 有孩子 B，而 B 有其他孩子。 因此，对于父 A，hierarchyLevel 是 2，对于 B，它应该是 1，对于 C，它应该是 0

例如，如果我使用 Id = 10 的项目，它有层次结构二（孙级别数）

 {ParentId = 10 , Id = 11, Name "aaa"}, 
  {ParentId = 11, Id = 13, Name "aaaaa"}, 

有没有更好的方法，或者简单的方法我可以获得这个 ChildCount 以及 Hierarchy 级别。

孩子总数示例：

Input is Id = 10 

total childs = 3. 

目前的做法：

RecursiveMethod(List)
{
 for each through the list and find the count 
call the RecursiveMethod again 
}

Answer 1

我对通用解决方案的尝试：

编辑：为解决方案添加了一些评论和其他改进

    /// <summary>
    /// Maps the nodes in a tree
    /// </summary>
    /// <param name="node">The node to process</param>
    /// <param name="level">
    /// the level of the node in the tree,
    /// 0 for the root node,
    /// 1 for children to the root etc.</param>
    /// <param name="childResults"> The result values for each of the children to the node </param>
    /// <returns> the result value for this node</returns>
    public delegate TResult TreeMapper<in T, TResult>(T node, int level, IEnumerable<TResult> childResults);

    /// <summary>
    /// Maps each node in a tree
    /// </summary>
    /// <param name="root">The root object of the tree</param>
    /// <param name="getChildren">Method to return all children of a node in the tree</param>
    /// <param name="map">
    /// Maps an item to some other type
    /// Inputs are:
    /// 1: The node of the tree
    /// 2: The level of the tree, starting with 0 for the root node
    /// 3: The results from each child to the node
    /// Returns: the result for the node
    /// </param>
    public static TResult MapChildren<T, TResult>(
        T root, 
        Func<T, IEnumerable<T>> getChildren,
        TreeMapper<T, TResult> map)
    {
        return RecurseBody(root, 0);

        TResult RecurseBody(T item, int level) 
            => map(item, level, getChildren(item).Select(child => RecurseBody(child, level + 1)));
    }

这可以在描述树的任何类型的 object 上递归，并计算某种值。 如果使用不同的映射方法，这可用于计算树的各种属性： 计算树中的节点总数：

(t, l, children) => children.Sum(c => c)+1;

获取树的最高层：

(t, l, children) => children.DefaultIfEmpty(l).Max()

该方法只为整个树产生一个结果。 如果要保留每个节点的结果，可以更新节点本身，或者保留带有节点->结果映射的字典

单元测试计算树中每个项目的级别和子项数量，类似于您的示例：

 public class TestItem
    {
        public TestItem(string name, TestItem[] children )
        {
            Children = children;
            Name = name;
        }
        public TestItem(string name) : this(name, new TestItem[0])
        { }
        public string Name { get; }
        public TestItem[] Children { get; }
    }

    [Test]
    public void Test()
    {
        TestItem test = new TestItem("A", new []
        {
            new TestItem("B", new []
            {
                new TestItem("C"),
                new TestItem("D")
            } ),
        } );

        // Compute the number of children to each node in the tree
        var childrenByItem = new Dictionary<string, int>();
        MapChildren<TestItem, int>(test, i => i.Children, 
            (item, level, childResults) => (childrenByItem[item.Name] = childResults.Sum(c => c)) + 1);

        Assert.AreEqual(3, childrenByItem["A"]);
        Assert.AreEqual(2, childrenByItem["B"]);
        Assert.AreEqual(0, childrenByItem["C"]);
        Assert.AreEqual(0, childrenByItem["D"]);

        // Compute the "Hierarchy Level", i.e. maximal distance to a leaf node, for each node
        var levelByItem = new Dictionary<string, int>();
        Tree.MapChildren<TestItem, int>(test, i => i.Children,
            (item, level, childResults) => levelByItem[item.Name] = childResults.DefaultIfEmpty(-1).Max() + 1);

        Assert.AreEqual(2, levelByItem["A"]);
        Assert.AreEqual(1, levelByItem["B"]);
        Assert.AreEqual(0, levelByItem["C"]);
        Assert.AreEqual(0, levelByItem["D"]);
    }

Answer 2

我们可以使用下面的方法来获取层次列表的深度

public static IEnumerable<Tuple<int, T>> FindDepthOfTreeNode<T>(T root, Func<T, IEnumerable<T>> children)
        {
            var stack = new Stack<Tuple<int, T>>();

            stack.Push(Tuple.Create(1, root));

            while (stack.Count > 0)
            {
                var node = stack.Pop();

                foreach (var child in children(node.Item2))
                {
                    stack.Push(Tuple.Create(node.Item1 + 1, child));
                }
                yield return node;
            }
        }

就像下面这样使用它

int depth = menuItem.Children == null ? 0 : menuItem.Children
                                .SelectMany(y => FindDepthOfTreeNode(y, xs => xs.Children ??
                                Enumerable.Empty<NavBarItem>()))
                                .Max(xs => xs.Item1);

为了获得分层列表节点中的总子数，我们可以使用以下方法。

public static int GetChildCountFromTree(this NavBarItem obj)
        {
            var queue = new Queue<NavBarItem>();
            queue.Enqueue(obj); // Note that you can add first object in the queue constructor

            var result = 0;

            while (queue.Any())
            {
                var current = queue.Dequeue();
                result++;
                if (null != current.Children)
                {
                    foreach (NavBarItem inner in current.Children)
                    {
                        queue.Enqueue(inner);
                    }

                    current.Last =  true;
                }
            }

            return result;
        }

我们可以像下面这样使用它

ourHirarchyNode.GetChildCountFromTree();

Answer 3

让我知道这是否适合您：

var lookup = items.ToLookup(x => x.ParentId);

(int children, int level) Recurse(int? parentId)
{
    var r = lookup[parentId].Select(x => Recurse(x.Id)).ToArray();
    return r.Any() ? (r.Sum(x => x.children + 1), r.Max(x => x.level) + 1) : (0, 0);
}

我的Recurse方法是一种本地方法。

这是我的测试代码：

void Main()
{
    var items = new[]
    {
        new NavBarItem() {ParentId = null, Id = 10, Name = "a"},
        new NavBarItem() {ParentId = null, Id = 33, Name = "aa"},
        new NavBarItem() {ParentId = 10 , Id = 11, Name = "aaa"},
        new NavBarItem() {ParentId = 10, Id = 12, Name = "aaaa"},
        new NavBarItem() {ParentId = 11, Id = 13, Name = "aaaaa"},
        new NavBarItem() {ParentId = 56 ,Id = 14, Name = "aas"},
        new NavBarItem() {ParentId = 78 , Id = 15, Name = "adss"},
        new NavBarItem() {ParentId = 99 , Id = 16, Name = "ader"},
    };

    var lookup = items.ToLookup(x => x.ParentId);

    (int children, int level) Recurse(int? parentId)
    {
        var r = lookup[parentId].Select(x => Recurse(x.Id)).ToArray();
        return r.Any() ? (r.Sum(x => x.children + 1), r.Max(x => x.level) + 1) : (0, 0);
    }

    var parents = new int?[] { null, 10, 11, 56, 78, 99 };

    Console.WriteLine(
        String.Join(
            Environment.NewLine,
            parents
                .Select(p => new { p, r = Recurse(p) })
                .Select(x => $"{x.p} => {x.r.children}, {x.r.level}")));
}

public class NavBarItem
{
    public int? Id { get; set; }
    public int? ParentId { get; set; }
    public string Name { get; set; }
}

我得到的结果是：

 => 5, 3
10 => 3, 2
11 => 1, 1
56 => 1, 1
78 => 1, 1
99 => 1, 1