Java N元树等于

我这样做是为了表示一个N元树：

public class MyTree {
    public int data;
    LinkedList<MyTree> children;


    public MyTree(int data) {
        this.data = data;
        this.children = new LinkedList<>();
    }

    public void addChild(MyTree child) {
        this.children.addFirst(child);
    }

    public boolean equals(MyTree root) { }
}

因此，我的想法是同时执行两个递归（一个使用this.tree，一个使用输入中的树），当函数探索第一个节点时，将其与第二个树的第一个节点进行比较，依此类推（它们必须遵守相同的顺序和值！），如下所示：

public boolean equals(MyTree t) {

    boolean result = true;
    if (this == null && t == null) {
        return false;
    }
    if (this == null || t == null) {
        return false;
    }
    if (this.getValue() != t.getValue()) {
        return false;
    }
    if (this.getChildren().size() != t.getChildren().size() ) {
        return false;
    }

    if (this.getChildren().size() == t.getChildren().size() ) {
        for (int i = 0; i < getChildren().size(); i++) {
            MyTree object = t.getChildren().get(i);
            MyTree object1 = this.getChildren().get(i);
            result = object1.equals(object);
            if (result == false) {
                return false;
            }
        }
    }

    return result;
}

---

递归如下：只有当相应的数据相等，子元素大小相等，每个子元素相等时，树才相等

public class MyTree {
public int data;
LinkedList<MyTree> children;


public MyTree(int data) {
    this.data = data;
    this.children = new LinkedList<>();
}

public void addChild(MyTree child) {
    this.children.addFirst(child);
}

public boolean equals(MyTree root) {
    if (root == null || root.children.size() != children.size() || data != root.data) return false;

    Iterator<MyTree> myTreeIterator = children.iterator();
    Iterator<MyTree> rootTreeIterator = root.children.iterator();
    while (myTreeIterator.hasNext() && rootTreeIterator.hasNext()) {
        if (!myTreeIterator.next().equals(rootTreeIterator.next())) return false;
    }
    return true;
}
}

公共类MyTree{
公共int数据；
社交网站儿童；
公共MyTree（int数据）{
这个数据=数据；
this.children=newlinkedlist（）；
}
公共void addChild（MyTree子级）{
this.children.addFirst（child）；
}
公共布尔等于（MyTree根）{
如果（root==null | | root.children.size（）！=children.size（）| | data！=root.data）返回false；
迭代器myTreeIterator=children.Iterator（）；
迭代器rootTreeIterator=root.children.Iterator（）；
while（myTreeIterator.hasNext（）&&rootTreeIterator.hasNext（））{
如果（！myTreeIterator.next（）.equals（rootTreeIterator.next（））返回false；
}
返回true；
}
}

UPD:@Gene-advice

public class MyTree {
public int data;
LinkedList<MyTree> children;


public MyTree(int data) {
    this.data = data;
    this.children = new LinkedList<>();
}

public void addChild(MyTree child) {
    this.children.addFirst(child);
}

@Override
public boolean equals(Object o) {
    return this == o || !(o == null || getClass() != o.getClass()) && equals((MyTree) o);
}

public boolean equals(MyTree root) {
    return !(root == null || data != root.data) && children.equals(root.children);
}
}

公共类MyTree{
公共int数据；
社交网站儿童；
公共MyTree（int数据）{
这个数据=数据；
this.children=newlinkedlist（）；
}
公共void addChild（MyTree子级）{
this.children.addFirst（child）；
}
@凌驾
公共布尔等于（对象o）{
返回this==o | |！（o==null | | getClass（）！=o.getClass（））&&equals（（MyTree）o）；
}
公共布尔等于（MyTree根）{
return！（root==null | | data！=root.data）&&children.equals（root.children）；
}
}

您知道如何迭代列表吗？您知道如何在特定索引处获取列表元素吗？是的，但例如，如果我使用两个for：一个用于第一棵树，另一个用于第二棵树，我认为它需要第一棵树的第一个元素，然后使用第二个for并获取第二棵树的第一个元素。。但我认为它会探索第二棵树的第二个节点，第二棵树的第三个节点等等。还是我弄错了？你可以检查一下

子列表的长度是否相同；然后假设它们是，使用一个
for
循环对两个列表进行迭代，对两个
子列表使用相同的索引。请注意，将其设置为
LinkedList
，使事情变得更加困难，因为在指定索引处获取元素意味着多次遍历整个列表。为了避免这种情况，您需要为两个具有
t.children.iterator（）
的列表获取列表迭代器，并手动使用迭代器方法，因为您不能使用
for
并行遍历两个迭代器。我从未使用过迭代器，也不知道它是什么，在那里使用迭代器有什么意义？@ajb我做了你的算法，但它似乎只探索根的值。我用代码编辑了问题。对不起，错过了，我认为你的迭代是不必要的
LinkedList
的
equals
方法已经实现了元素相等。你应该重写基
equals（Object obj）
，并利用这个事实使你的代码更简单。我同意你的观点，但这段代码是OP契约的实现，首先给出了正确递归的明确见解为什么迭代器更好用？@HKing抱歉，比什么更好？
public class MyTree {
public int data;
LinkedList<MyTree> children;


public MyTree(int data) {
    this.data = data;
    this.children = new LinkedList<>();
}

public void addChild(MyTree child) {
    this.children.addFirst(child);
}

public boolean equals(MyTree root) {
    if (root == null || root.children.size() != children.size() || data != root.data) return false;

    Iterator<MyTree> myTreeIterator = children.iterator();
    Iterator<MyTree> rootTreeIterator = root.children.iterator();
    while (myTreeIterator.hasNext() && rootTreeIterator.hasNext()) {
        if (!myTreeIterator.next().equals(rootTreeIterator.next())) return false;
    }
    return true;
}
}

public class MyTree {
public int data;
LinkedList<MyTree> children;


public MyTree(int data) {
    this.data = data;
    this.children = new LinkedList<>();
}

public void addChild(MyTree child) {
    this.children.addFirst(child);
}

@Override
public boolean equals(Object o) {
    return this == o || !(o == null || getClass() != o.getClass()) && equals((MyTree) o);
}

public boolean equals(MyTree root) {
    return !(root == null || data != root.data) && children.equals(root.children);
}
}