Data structures 用于树的子级的适当数据结构

所以我想实现一个树的严格定义-一个没有任何循环的图。递归地，它是一个具有n个子树/子树的节点。因此，每个节点都需要某种数据结构将其与n个子树相关联

• 数组、列表、序列、有序集合：子级实际上没有顺序。有一种称为“有序树”的特殊类型的树，它确实将某种排序与节点的子节点相关联，但这在这里似乎不合适
  例如：

  树（3，
  树（4），
  树（5）
  )==树（3，
  树（5），
  树（4）
  )

• 集合：集合不按顺序排列，但也不包含重复项。从功能上讲，如果树（3）=树（3），这是有意义的，但我们需要重复的信息，因为一个节点可以有多个树（3）作为子树
  例如：

  树（3，
  树（4）
  ) != 树（3，
  树（4），
  树（4）
  )

• 袋子：一种无序的集合，允许添加物品，但不允许删除任何物品。这似乎与树上的孩子可以被移除的事实不一致

是否有其他无序的数据结构更适合？我相信这以前是个问题，常见的解决方案是什么

---

谢谢

如果子项顺序不重要并且允许复制，我认为

列表

就足够了

由于无法保证子级将在列表中排序或以正确的顺序插入，并且由于允许重复，因此不能使用

集合

，因此我们可以定义如何比较两棵树，以便

树（3，ArrayList（tree（4），tree（5））

和

树（3，ArrayList（tree（5），tree（4））

可以进行相等的比较

一种方法是——在比较它们是否相等时，我们可以根据它们的值对子对象进行排序，并递归地进行比较

class Tree {
    private Integer value;
    private List<Tree> children;

    // getter for value
    // getter for children

    public Tree(Integer value) {
        this.value = value;
        children = new ArrayList<>();
    }

    @Override
    public boolean equals(Object other) {
        if (other == this) {
            return true;
        }
        if (!(other instanceof Tree)) {
            return false;
        }
        Tree otherTree = (Tree) other;

        return equalUtil(this, otherTree);
    }

    private boolean equalUtil(Tree lhs, Tree rhs) {
        if(lhs == null && rhs == null) {
            return true;
        }

        if(lhs == null || rhs == null) {
            return false;
        }


        if(lhs.children.size() != rhs.children.size()) {
            return false;
        }

        // copying the children into another list to not altering
        // the tree's data ordering
        lhsChildren = lhs.children;
        Collections.sort(lhsChildren, new TreeComparator());

        rhsChildren = rhs.children;
        Collections.sort(rhsChildren, new TreeComparator());

        for(int i = 0; i < lhsChildren.size(); i++) {
            if(!equalUtil(lhsChildren[i], rhsChildren[i])) {
                return false;
            }
        }

        return true;

    }

    static class TreeComparator implements Comparator<Tree> {
        @Override
        public int compare(Tree lhs, Tree rhs) {
            return lhs.getValue().compareTo(rhs.getValue());
        }
    }
}

类树{
私有整数值；
私人名单儿童；
//价值吸气剂
//儿童吸气剂
公共树（整数值）{
这个值=值；
children=newarraylist（）；
}
@凌驾
公共布尔等于（对象其他）{
如果（其他==此）{
返回true；
}
if（！（树的其他实例））{
返回false；
}
Tree otherTree=（Tree）other；
返回equalUtil（此，其他树）；
}
私有布尔等式（树lhs、树rhs）{
if（lhs==null&&rhs==null）{
返回true；
}
如果（lhs==null | | rhs==null）{
返回false；
}
if（lhs.children.size（）！=rhs.children.size（））{
返回false；
}
//将子项复制到另一个列表中以避免更改
//树的数据排序
lhsChildren=lhs.儿童；
Collections.sort（lhsChildren，newtreecomprator（））；
rhsChildren=rhs.儿童；
Collections.sort（rhsChildren，新的树比较器（））；
对于（int i=0；i

我不知道到目前为止您尝试了什么-无序将通过硬编码节点及其子节点之间的链接来完成。-就像二叉树一样。如果您想要一个有序的树，那么您可以尝试BST或Max/Min heap。您可以查看此链接：硬编码似乎只有在具有固定数量的BinTree之类的东西时才真正起作用我想有一种方法可以像一个有顶点和节点的图一样表示整个事物。但这就摆脱了保证无循环的规则。我觉得这里可能有一个优雅的解决方案，比如hashmap，但这需要定义一些哈希。a非常有用的数据结构是一个。它可以让您非常简单地表示任何类型的树，每个节点具有任意数量的子节点。但是，我确信这将使相等比较变得困难，因为需要检查同级链接列表的内容，而不考虑其顺序。我觉得哈希表可能最适合相等这似乎是一种蛮力的比较，比如树（3，ArrayList，树（4），树（5））！=Tree（3，ArrayList，树（5），树（4））我想你可以让两个ArrayList保持有序，但不能保证树封装的值会有有序。啊，好吧。现在我明白你的问题了。让我更新我的答案