Question

我有一个嵌套集合，我希望在循环解析到嵌套集合之前循环遍历父集合中的每个元素，

到目前为止我尝试过的是，

Private void Loop( PreviewObject  po ) 
{ 
             Console.Writeline(po.Name) ; 

            foreach (PreviewObject child in po.Childrens)
                Loop( child);
}

PreviewObject类

public class PreviewObject
    {
        private string _name;
        public string Name { get { return _name; } set { _name = value; } }

        private List<PreviewObject> _childrens = new List<PreviewObject>();
        public List<PreviewObject> Childrens
        {
            get { return _childrens; }
            set { _childrens = value; }
        }
    }

问题是循环就像这样

假设X为集合，而X具有元素X，这意味着嵌套集合

X第一个元素是A， X第二个元素是B， X的第一个元素集合的第一个元素是C

如果我将其作为我的代码循环，我会得到以下结果，

一个 C X

我想要的是，

一个
乙 C

A和B都是父集合的元素所以我想首先遍历所有父元素，循环遍历元素内部父元素的集合

任何人都可以帮助我实现这个目标吗？

我尝试了以下代码，但它也给了我相同的结果

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections ; 

namespace Breadth_first_traversal
{
    class Program
    {
        public static void Main(string[] args)
        {
            list a  = new list();
            a.name = "A";

            list b = new list();
            b.name = "B";
            list c = new list();
            c.name = "C";
            list d = new list();
            d.name = "d";

            list parent = new list();
            parent.name = "Parent";

            parent.Childrens.Add(a);
            parent.Childrens.Add(b);

            a.Childrens.Add(c);
            b.Childrens.Add(d);

            Loop(a);

            Console.ReadKey();
        }
        private static  void Loop(list  po)
        {
            Queue<list> queue = new Queue<list>();
            queue.Enqueue(po);

            while (queue.Count != 0)
            {
                list  next = queue.Dequeue();
                foreach (list  obj in next.Childrens)
                    queue.Enqueue(obj);

                // Replace with the actual processing you need to do on the item
                Console.WriteLine(next.name);
            }
        }

        public class list
        {
            public string _name;
            public string name { get { return _name; } set { _name = value; } }  

            private List<list> childrens = new List<list>(); 
            public List<list> Childrens { get { return childrens ; }  set {childrens  = value ; }   } 
        } 
    } 
}

上面代码得到的结果是

一个 C

但我必须得到的是

一个乙 C d

因为首先将父集合的所有元素写入控制台然后将父级的集合元素集合写入控制台

有人可以用一个很好的代码示例回答吗？

Answer 1

您正在寻找的东西称为广度优先遍历。您可以通过维护要访问的节点队列来实现它。将集合的根添加到Queue。现在，开始从队列中提取项目。当您获得每个项目时，对其执行任何处理，然后将其所有子项添加到队列的末尾。继续从队列中拉出节点并处理它们，直到队列为空。

编辑：示例代码

private void Loop(PreviewObject po)
{
    Queue<PreviewObject> queue = new Queue<PreviewObject>();
    queue.Enqueue(po);

    while(queue.Count != 0)
    {
        PreviewObject next = queue.Dequeue();
        foreach(PreviewObject obj in next.Childrens)
            queue.Enqueue(obj);

        // Replace with the actual processing you need to do on the item
        Console.WriteLine(next.Name);
    }
}

如何在嵌套集合中的子记录之前循环父项？

1 个答案: