Question

我有以下课程：

class Person 
{
    public string Name { get; set; }
    public List<Person> Children { get; set; } 
}

我创建了这个类的实例，fox ex。

Person pers = new Person();

我可以静态编码foreach循环并将Children存储在某个列表中：

foreach (var item in pers.Children)
{
    List<Person> r = item.Children;
    foreach (var item2 in item.Children)
    {
        List<Person> k = item2.Children;
        foreach (var item3 in item2.Children)
        {
        etc..
        }
    }
}

问题是，如果“ pers ”有一个孩子，如何对foreach循环进行编码，他的一个孩子（ pers.Children ）也有一个儿童。这就像家谱树一样。

我的意思是，如何让它更动态？因为我不知道这个家庭的结构如何。

编辑：我只想展示一个人的所有继承人。例如，他的继任者的名字

Answer 1

使用递归：

public static void ShowAll(Person pers)
{
    Console.WriteLine(pers.Name);
    foreach (var item in pers.Children)
    {
        ShowAll(item);
    }
}

Answer 2

您可以这样做的另一种方法是向您的班级添加一个方法，该方法将显示该人的姓名（和/或其他数据），然后显示他们孩子的姓名（和/或其他数据））通过在每个子实例上调用方法。

这种方法的好处在于它使您的代码更加清晰，并将其留给Person类来处理它自身的显示方式（以及它的后继者）。

以下是使用此类方法修改过课程的示例：

public class Person
{
    public string Name { get; set; }
    public List<Person> Children { get; set; }

    public Person()
    {
        Children = new List<Person>();
    }

    public void DisplaySuccessors(int indendationLevel = 0)
    {
        Console.WriteLine("{0}{1}", new String('.', indendationLevel * 2), Name);

        foreach (var child in Children)
        {
            child.DisplaySuccessors(indendationLevel + 1);
        }
    }
}

以下是如何使用它的：

private static void Main()
{
    var mother = new Person {Name = "Mother"};

    var daughter1 = new Person {Name = "daughter1"};
    var granddaughter1 = new Person { Name = "granddaughter1" };

    var son1 = new Person { Name = "son1" };
    var grandson1 = new Person { Name = "grandson1" };
    var granddaughter2 = new Person { Name = "granddaughter2" };

    mother.Children.Add(daughter1);
    mother.Children.Add(son1);
    daughter1.Children.Add(granddaughter1);
    son1.Children.Add(grandson1);
    son1.Children.Add(granddaughter2);

    mother.DisplaySuccessors();
}

输出：

母亲   ..女儿1   ....孙女1   ..son1
  ....孙子1   ....孙女2

Answer 3

已经深入讨论了处理树状数据结构： Tree Data Structure

Answer 4

一种方法是递归，就像这个调用自身的方法一样：

static void WriteAllSuccessors(Person pers, int depth = 0)
{
  var indent = new string(' ', depth * 4);
  Console.WriteLine(indent + pers.Name);
  foreach (var child in pers.Children)
      WriteAllSuccessors(child, depth + 1);
}

请注意缩进。

Answer 5

这是标准递归，您可以调用自身并将节点添加到某个列表中：

static void Main(string[] args)
        {
            List<Person> successors = new List<Person>();

            var person = new Person()
            {
                Name = "GrandFather",
                Children = new List<Person>()
                {
                    new Person()
                    {
                        Name = "Son",
                        Children = new List<Person>()
                        {
                            new Person()
                            {
                                Name = "SonOfSon"
                            }

                        }
                    },
                    new Person()
                    {
                        Name = "Daughter",
                        Children = new List<Person>()
                        {
                            new Person()
                            {
                                Name = "DaughterOfDaughter"
                            }
                        }
                    }
                }
            };

            SearchForSuccessors(person.Children, successors);
        }

        public static void SearchForSuccessors(List<Person> persons, List<Person> successors)
        {
            foreach(var person in persons )
            {
                successors.Add(person);

                if (person.Children != null)
                    SearchForSuccessors(person.Children, successors);
            }
        }

如何在List <t> </t>中编写foreach中的变量循环级别

5 个答案: