1

我有一个IList<Category>

类别类型来自我在 SQL Server 中的类别表：

表：类别

类别 ID、父类别 ID

如此典型的层次结构在一张桌子上。

因此，如果我有这个包含节点关系的类别 IList，那么我试图弄清楚这如何适合像很多人一样制作节点和树。构造函数的外观和创建这个类的使用情况如何？

我认为在这里创建一个通用的 Node 类和 Tree 类是有意义的，这样我可以在将来重用我认为的其他树类型。

所以如果我有这样的东西，T 是如何被使用的，我从中受益了什么？

（这里是伪代码）

public class Node<T>
...
    Node<T> _parentNode;
    List<Node<T>> _children;

    private void SetParentNode(T)
    private void AddChild(T)

... etc.

试图在这里理解关于为什么通用节点类将用于任何类型的概念，例如 Childeren 等，其中包含子/父关系（int Ids）

更新

因此，这里的 GroupBy 建议存在问题。看看我试图用你的例子做什么：

首先，我的 Tree 类中有这个属性：

公共字典，IList>> ParentNodeAndRelatedChildrenFlattenedMap { get; 私人套装；}

并且传入我的类的构造函数的是一个 IList 依赖项，我将它转换（循环并为它们中的每一个创建一个新节点）到 IList>

现在，我正在尝试按 Node.ParentId 对该列表进行分组，以便在父节点上进行分组，并且由于每个节点都有其子属性，因此很容易找出与这些父节点相关的子节点。

但这是我代码中的问题：

public void CreateFlattenedMap()
{
    var parentGroups = _nodeDependencies.GroupBy(d => d.ParentNodeId);

    var dictionary = parentGroups.ToDictionary(d => d, d => d.ToList());

    ParentNodeAndRelatedChildrenFlattenedMap = dictionary;
}

好吧，它不喜欢我对字典的分配，因为它是由 ToDictionary() 创建的 > 字典。所以不知道如何将这个分组分组到一个字典中，List> 其中字典中的节点是我分组的父节点的节点实例（是的，我在它的 Node.ParentId 上分组，但我想要节点虽然在最后的 ToDictionary 中）并且 List> 是来自 Parent Node.Children 属性的子节点列表。

4

3 回答 3

3

这是一个更完整的实现的样子：

public class TreeNode<T>
{
    private T _item;
    private TreeNode<T> _parentNode;
    private List<TreeNode<T>> _children;

    public TreeNode(T item)
    {
        _item = item;
    }

    public void SetParentNode(T parent)
    {
        _parentNode.Item = parent;
    }

    public T Item
    {
        get { return _item; }
        set { _item = value; }
    }

    public void AddChild(T child)
    {
        _children.Add(new TreeNode<T>(child));
    }

    public void RemoveChild(T child)
    {
        var node = _children.FirstOrDefault(e => e.Item.Equals(child));
        if (node != null)
            _children.Remove(node);
    }
}

还有你的问题：

构造函数的外观如何，这个类在使用方面是如何创建的？

从上面在 中可以看出AddChild()，只需为构造函数指定子的类型即可。

var node = new TreeNode<T>(item);

所以如果我有这样的东西，它是如何T被使用的，我从中受益了什么？

如果做得好，泛型的使用可能会花费大量时间重写代码。在上面的实现中，我们可以通过简单地改变T. 因此，如果我们需要一种以上类型的树结构，这可以为我们节省大量时间。

var intTreeNode = new TreeNode<int>(10);
var stringTreeNode = new TreeNode<string>("hello world");

通常在点击之前确实需要一些曝光时间，然后你“就明白了”，坚持下去。

构建树

要从可能有也可能没有父类别的类别列表构建树，您需要以某种方式遍历列表。解决这个问题的一个不错的方法是首先将它们组织成基于ParentCategoryID和构建树的分组。像这样的东西（未经测试）：

public List<TreeNode<Category>> ConstructCategories(List<Category> categories)
{
    var groups = categories.GroupBy(e => e.ParentCategoryID);
    var rootGroup = groups.Single(e => e.Key == null);
    var categories = List<TreeNode<Category>>();

    foreach (var category in rootGroup)
    {
        // Create and fill category
        var node = new TreeNode<Category>(category);
        ConstructChildrenCategories(node, groups);
        categories.Add(node);
    }
}

public void ConstructChildrenCategories(TreeNode<Category> node, IEnumerable<IGrouping<Category>> groups)
{
    var group = groups.Single(e => e.Key == node.Item.CategoryID);

    foreach (var category in group)
    {
        // Create and fill category
        var childNode = new TreeNode<Category>(category);
        ConstructChildrenCategories(childNode, groups);

        // We could do this automatically in both methods.
        childNode.SetParent(node.Item);
        node.AddChild(childNode);
    }
}
于 2013-03-29T05:53:05.887 回答
2

这可能会有所帮助：

public interface ICategory
{
    int Id { get; }
    int ParentId { get; }
}

public class Category : ICategory
{
    int id;
    int parentId;

    public int Id { get { return id; }}
    public int ParentId { get { return parentId; }}
}

这是Node课程：

public class Node<T> where T : ICategory
{
    Node<T> _parentNode;
    List<Node<T>> _children;

    public Node<T> Parent { get { return _parentNode; }}

    public Node<T> Child(int index) { return _children[index]; }

    public T Value;

    public Node(T value)
    {
        this.Value = value;
    }

    public void AddChild(T item)
    {
        Node<T> child = new Node<T>(item);
        this._children.Add(child);
        child._parentNode = this;
    }
}

这是Tree课程：

public class Tree<T> where T : ICategory
{
    List<Node<T>> values;

    public Tree()
    {
        this.values = new List<Node<T>>();
    }

    public Node<T> FindNode(int id)
    {
        if (values.Exists(input => input.Value.Id == id))
        {
            return values.Find(input => input.Value.Id == id);
        }
        else { return null; }

    }

    public void AddNode(T value)
    {
        Node<T> parent = FindNode(value.ParentId);

        if (parent != null)
        {
            parent.AddChild(value);
        }
    }
}
于 2013-03-29T06:08:39.750 回答
-1

你不能使树和树节点的所有功能。

而是将类数据添加到 Treenode。

例如

class MyClass
{
    public int A;
    public string B;
}

...

TreeNode Node = TreeView.Nodes.Add("AAA");
MyClass Data = new MyClass();
Node.Tag = Data;

分配给 TreeNode 的数据不会被删除。您也可以使用整个树属性和节点成员。

您唯一应该做的就是在使用节点数据时进行类型转换。

TreeNode Node = TreeView.Nodes[0];
MyClass Temp = Node.Tag as MyClass;
于 2016-09-08T14:17:30.157 回答