Question

我会尽力解释这个问题。我试图找出这个逻辑时遇到了很多困难。

基本上，我有一个包含数千个对象的集合，每个对象都由Parent和Child属性组成。

所以，粗略地说，这个：


public class MyObject{
     public string Parent { get; set; }
     public string Child { get; set; }
}

我想弄清楚的是如何将它构建到一个普通的TreeView控件中。我需要建立关系，但我无法弄清楚如何，因为他们可以混合。我可以用树的外观来解释这个问题：

所以如果我的藏品中有以下物品：


0. Parent: "A", Child: "B"
1. Parent: "B", Child: "C"
2. Parent: "B", Child: "D"

我希望我的树看起来像：


-A
--B
---C
-A
--B
---D
-B
--C
-B
--D

我怎样才能在C＃中做到这一点？我需要它来支持N个关系，因为我们有一些分支，我希望它能够达到约50个节点。

Answer 1

<强>更新

这个问题实际上比我最初意识到的要复杂得多，因为需要为每条路径重复整个树。我只是删除了旧代码，因为我不想再添加任何混淆。

我确实希望保持记录，使用递归数据结构可以使这更容易：

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

在阅读下面的实施代码后，您会非常清楚地看到为什么这会更容易：

private void PopulateTree(IEnumerable<MyObject> items)
{
    var groupedItems =
        from i in items
        group i by i.Parent into g
        select new { Name = g.Key, Children = g.Select(c => c.Child) };
    var lookup = groupedItems.ToDictionary(i => i.Name, i => i.Children);
    foreach (string parent in lookup.Keys)
    {
        if (lookup.ContainsKey(parent))
            AddToTree(lookup, Enumerable.Empty<string>(), parent);
    }
}

private void AddToTree(Dictionary<string, IEnumerable<string>> lookup,
    IEnumerable<string> path, string name)
{
    IEnumerable<string> children;
    if (lookup.TryGetValue(name, out children))
    {
        IEnumerable<string> newPath = path.Concat(new string[] { name });
        foreach (string child in children)
            AddToTree(lookup, newPath, child);
    }
    else
    {
        TreeNode parentNode = null;
        foreach (string item in path)
            parentNode = AddTreeNode(parentNode, item);
        AddTreeNode(parentNode, name);
    }
}

private TreeNode AddTreeNode(TreeNode parent, string name)
{
    TreeNode node = new TreeNode(name);
    if (parent != null)
        parent.Nodes.Add(node);
    else
        treeView1.Nodes.Add(node);
    return node;
}

首先，我意识到字典将包含中间节点以及根节点的密钥，因此我们不需要在递归AddToTree方法中进行两次递归调用以获得“ B“节点作为根; PopulateTree方法中的初始步行已经完成。

我们做需要防范的是在初始步行中添加叶节点;使用所讨论的数据结构，可以通过检查父词典中是否存在密钥来检测这些数据结构。使用递归数据结构，这将更容易：只需检查Parent == null。但是，递归结构不是我们所拥有的，所以上面的代码就是我们必须使用的。

AddTreeNode主要是一种实用工具方法，因此我们不必在以后继续重复这种空检查逻辑。

真正的丑陋是第二种递归AddToTree方法。因为我们正在尝试创建每个子树的唯一副本，所以我们不能简单地添加树节点，然后将该节点作为父节点递归。 “A”在这里只有一个孩子，“B”，但“B”有两个孩子，“C”和“D”。需要有两个“A”副本，但是当“A”最初传递给AddToTree方法时，无法知道这一点。

所以我们实际要做的就是在最后阶段之前不创建任何节点，并存储一个临时路径，我选择了IEnumerable<string>，因为它是不可变的，因此是不可能的搞砸了。当有更多子项要添加时，此方法只是添加到路径并递归;当没有更多的孩子时，它会遍历整个保存的路径并为每个路径添加一个节点。

这非常效率低下，因为我们现在正在AddToTree的每次调用中创建一个新的可枚举。对于大量节点，它可能会扼杀大量内存。这可行，但使用递归数据结构会更有效。使用顶部的示例结构，您根本不必保存路径或创建字典;当没有孩子离开时，只需使用while引用在Parent循环中沿着路径走。

无论如何，我认为这是学术性的，因为这不是一个递归的对象，但我认为值得指出，无论如何要记住未来的设计。 上面的代码将生成您想要的结果，我已经在真正的TreeView上进行了测试。

更新2 - 事实证明上述版本在内存/堆栈方面非常残酷，很可能是创建所有IEnumerable<string>个实例的结果。虽然它不是很好的设计，但我们可以通过更改为可变List<string>来删除该特定问题。以下代码段显示了不同之处：

private void PopulateTree(IEnumerable<MyObject> items)
{
    // Snip lookup-generation code - same as before ...

    List<string> path = new List<string>();
    foreach (string parent in lookup.Keys)
    {
        if (lookup.ContainsKey(parent))
            AddToTree(lookup, path, parent);
    }
}

private void AddToTree(Dictionary<string, IEnumerable<string>> lookup,
    IEnumerable<string> path, string name)
{
    IEnumerable<string> children;
    if (lookup.TryGetValue(name, out children))
    {
        path.Add(name);
        foreach (string child in children)
            AddToTree(lookup, newPath, child);
        path.Remove(name);
    }
    // Snip "else" block - again, this part is the same as before ...
}

Answer 2

像rubens一样，我试过了两个，但我认为A Generic Tree Collection

更好一些

这个树集合有一些很好的功能内置在树上移动，请阅读整篇文章

带有上面链接的示例

Static Class Module1
{

    public static void Main()
    {
        Common.ITree<myObj> myTree = default(Common.ITree<myObj>);
        myObj a = new myObj("a");
        myObj b = new myObj("b");
        myObj c = new myObj("c");
        myObj d = new myObj("d");

        myTree = Common.NodeTree<myObj>.NewTree;
        myTree.InsertChild(a).InsertChild(b).InsertChild(c).Parent.Parent.InsertNext(a).InsertChild(b).InsertChild(d).Parent.Parent.InsertNext(b).InsertChild(c).Parent.InsertNext(b).InsertChild(d);

        Console.WriteLine(myTree.ToStringRecursive);

        Console.ReadKey();
    }
}

Class myObj
{
    public string text;

    public myObj(string value)
    {
        text = value;
    }

    public override string ToString()
    {
        return text;
    }
}

正是你刚刚展示的

-A
  --B
  ---Ç
  -A
  --B
  --- d
  -B
  --C
  -B
  --D

Answer 3

如果我理解正确的话，你要做的就是拿一棵树把它变成另一棵树。转换实质上是在输入树中获取每个非叶节点，并在输出树中为它（及其后代）创建一个节点。

首先，如果您为节点设计真正递归的数据结构，您会更高兴：

public class Node
{
   public Node Parent { get; private set; }
   public IEnumerable<Node> Children { get; private set; }
   public bool HasChildren { get { return Children.Count() > 0; } }

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

您的MyObject类表示字符串值之间的父/子关系。只要您能够实现返回给定父值的子值的FindChildren()方法，使用此类来合理化父/子关系就很简单：

public string Value { get; set; }
public static Node Create(string parentKey)
{
   Node n = new Node();
   n.Value = parentKey;
   foreach (string childKey in FindChildren(parentKey))
   {
      Node child = n.Children.Add(Node.Create(childKey));
      child.Parent = n;
   } 
   return n;
}

实现返回节点后代的属性很简单：

public IEnumerable<Node> Descendants
{
   get
   {
      foreach (Node child in Children)
      {
         yield return child;
         foreach (Node descendant in child.Descendants)
         {
            yield return descendant;
         }
      }
   }
}

要向TreeView添加Node，您需要两种方法。（请注意，这些不是Node类的方法！）我已经使它们重载，但是可以为它们赋予不同的名称：

public void AddNode(Node n, TreeView tv)
{
   TreeNode tn = tv.Nodes.Add(n.Value);
   tn.Tag = n;
   foreach (Node child in n.Children)
   {
      AddNode(child, tn);
   }
}

public void AddNode(Node n, TreeNode parent)
{
   TreeNode tn = parent.Nodes.Add(n.Value);
   parent.Tag = n;
   foreach (Node child in n.Children)
   {
      AddNode(child, tn);
   }
}

我在每个Tag设置了TreeNode，以便您可以找到返回原始Node的路径。

因此，要从顶级父键列表初始化TreeView，您需要这样的方法：

public void PopulateTreeView(IEnumerable<string> parents, TreeView t)
{
   foreach (string parentKey in parents)
   {
      Node n = Node.Create(parentKey);
      AddNode(n, t);
      foreach (Node descendant in n.Descendants)
      {
         if (n.HasChildren)
         {
            AddNode(descendant, t);
         }
      }
   }
}

修改

我不太明白你的MyObject课是如何工作的;我想我现在就做了，我已经相应地编辑了这个。

围绕N parent-＆gt;子关联我的头脑

3 个答案: