Java 比较两棵树的Equals方法

我最近一直在学习java。我创造了两棵树。我需要编写代码（equals方法）来比较两棵树，如果它们相同，则输出true或false

我的代码：

public class TreePrint {

    public static void main(String[] args) {

        Tree<String> rootFolder = new Tree<>("RootFolder");

        Node<String> video = rootFolder.addChild("Video");
        Node<String> music = rootFolder.addChild("Music");
        Node<String> picture = rootFolder.addChild("Picture");

        video.addChild("Terminator");
        video.addChild("Die Hard");
        video.addChild("Rocky");
        music.addChild("Eminem");
        Node<String> picture01 = picture.addChild("Picasso");
        picture01.addChild("Do Vinci");
        Node<String> picture02 = picture01.addChild("Adil");
        picture02.addChild("Cartoon");
        picture02.addChild("Comics");

         Tree2<String> rootFolder1 = new Tree2<>("RootFolder1");

        Node<String> video1 = rootFolder1.addChild("Video");
        Node<String> music1 = rootFolder1.addChild("Music");
        Node<String> picture1 = rootFolder1.addChild("Picture");

        video1.addChild("Terminator");
        video1.addChild("Die Hard");
        video1.addChild("Rocky");
        music1.addChild("Eminem");
        Node<String> picture001 = picture1.addChild("Picasso");
        picture001.addChild("Do Vinci");
        Node<String> picture002 = picture001.addChild("Adil");
        picture002.addChild("Cartoon");
        picture002.addChild("Comics");


        printTree(rootFolder);
        printTree(rootFolder1);


        boolean b1 = rootFolder.contains("P0");
        System.out.println(b1);
        boolean b2 = rootFolder1.contains("Eminem");
        System.out.println(b2);
    }

    private static <T> void printTree(Node<T> node) {
        printTree(node, 0);
    }

    private static <T> void printTree(Node<T> node, int level) {
        printNode(node, level);
        if (node.getChildren() != null) {
            for (Node childNode : node.getChildren()) {
                printTree(childNode, level + 1);
            }
        }
    }

    private static <T> void printNode(Node<T> kid, int level) {

        for (int i = 0; i < level; i++) {
            System.out.print("  ");
        }

        System.out.println(kid.getData());
    }
}

公共类树打印{
公共静态void main（字符串[]args）{
Tree rootFolder=新树（“rootFolder”）；
Node video=rootFolder.addChild（“视频”）；
Node music=rootFolder.addChild（“音乐”）；
节点图片=rootFolder.addChild（“图片”）；
视频。addChild（“终结者”）；
addChild（“死硬派”）；
视频。addChild（“Rocky”）；
音乐。addChild（“Eminem”）；
节点picture01=picture.addChild（“毕加索”）；
图01.addChild（“Do Vinci”）；
节点picture02=picture01.addChild（“Adil”）；
图片02.addChild（“卡通”）；
图片02.addChild（“漫画”）；
Tree2 rootFolder1=新的Tree2（“rootFolder1”）；
节点video1=rootFolder1.addChild（“视频”）；
节点music1=rootFolder1.addChild（“音乐”）；
节点picture1=rootFolder1.addChild（“Picture”）；
video1.addChild（“终结者”）；
视频1.addChild（“死硬派”）；
视频1.addChild（“Rocky”）；
音乐1.addChild（“Eminem”）；
节点picture001=picture1.addChild（“毕加索”）；
图001.addChild（“Do Vinci”）；
节点picture002=picture001.addChild（“Adil”）；
图片002.addChild（“卡通”）；
图片002.addChild（“漫画”）；
printree（rootFolder）；
printree（rootFolder1）；
布尔b1=rootFolder.contains（“P0”）；
系统输出打印LN（b1）；
布尔b2=rootFolder1.contains（“Eminem”）；
系统输出打印LN（b2）；
}
私有静态void打印树（节点）{
打印树（节点，0）；
}
私有静态void打印树（节点，int级别）{
printNode（节点，级别）；
if（node.getChildren（）！=null）{
对于（Node-childNode:Node.getChildren（））{
打印树（子节点，级别+1）；
}
}
}
私有静态void printNode（节点kid，int级别）{
对于（int i=0；i

---

第一棵树：

public class Tree<T> extends Node<T> {

    public Tree(T data) {

        super(data, null);
    }
    public boolean contains(T value) {
        return recurse(iterate(), value);
    }

    private boolean recurse(List<Node<T>> children, T value) {
        return children.stream()
                .anyMatch(item -> item.getData().equals(value) || item.iterate().size() > 0 && recurse(item.iterate(), value));
    }


}

公共类树扩展节点{
公共树（T数据）{
super（数据，空）；
}
公共布尔包含（T值）{
返回递归（iterate（），value）；
}
私有布尔递归（列出子项，T值）{
返回children.stream（）
.anyMatch（item->item.getData（）.equals（value）| | item.iterate（）.size（）>0&&recurse（item.iterate（），value））；
}
}

---

公共类节点{
私有T数据；
private final List children=new ArrayList（）；
私有最终节点父节点；
公共节点（T数据，节点父节点）{
这个数据=数据；
this.parent=parent；
}
公共void addChild（节点）{
添加（节点）；
}
公共节点addChild（T nodeData）{
Node newNode=新节点（nodeData，this）；
添加（newNode）；
返回newNode；
}
公共列表迭代（）{
返回儿童；
}
公共无效删除（节点）{
移除（节点）；
}
公共列表getChildren（）{
返回儿童；
}
公共节点getParent（）{
返回父母；
}
公共T getData（）{
返回数据；
}
公共无效设置数据（T数据）{
这个数据=数据；
}

---

第二棵树：

public class Tree2<T> extends Node<T> {

    public Tree2(T data) {

        super(data, null);
    }
    public boolean contains(T value) {
        return recurse(iterate(), value);
    }

    private boolean recurse(List<Node<T>> children, T value) {
        return children.stream()
                .anyMatch(item -> item.getData().equals(value) || item.iterate().size() > 0 && recurse(item.iterate(), value));
    }
}

公共类Tree2扩展节点{
公共树2（T数据）{
super（数据，空）；
}
公共布尔包含（T值）{
返回递归（iterate（），value）；
}
私有布尔递归（列出子项，T值）{
返回children.stream（）
.anyMatch（item->item.getData（）.equals（value）| | item.iterate（）.size（）>0&&recurse（item.iterate（），value））；
}
}

---

然后对两棵树的根节点使用此方法。

将以下方法添加到节点类中。由于树也是一个节点，您应该能够比较两棵树。仅供参考，这是Eclipse自动生成的

public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Node other = (Node) obj;
    if (children == null) {
        if (other.children != null)
            return false;
    } else if (!children.equals(other.children))
        return false;
    if (data == null) {
        if (other.data != null)
            return false;
    } else if (!data.equals(other.data))
        return false;
    return true;
}

---

当两棵树具有相同的数据时，它们是相同的。要确定两棵树是否相同，您需要同时遍历这两棵树，并且在遍历时，您需要比较数据和树的子树。您可以编写equals方法吗？这是一个java算法和代码：为什么有两个类的操作完全相同？您需要的是两个树对象，而不是两个树类。@AdilAzrael您的树表示过于复杂。您不需要

树

和

树2

类（1个树=1个

节点的实例

，2个树=2个

节点的实例

），您也不需要

节点

类上的

parent

属性。我有另一个树。我不会写equals，但我最近学习了java。记住添加一个

hashcode

方法，也是对

equals

方法的补充。如何在类树中运行它可以帮助完成剩下的一点练习在treePrint类中运行它如何在treePrint类中运行

/* Given two trees, return true if they are
   structurally identical */
boolean identicalTrees(Node a, Node b) 
{
    /*1. both empty */
    if (a == null && b == null)
        return true;

    /* 2. both non-empty -> compare them */
    if (a != null && b != null) 
        return (a.data == b.data
                && identicalTrees(a.left, b.left)
                && identicalTrees(a.right, b.right));

    /* 3. one empty, one not -> false */
    return false;
}

public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Node other = (Node) obj;
    if (children == null) {
        if (other.children != null)
            return false;
    } else if (!children.equals(other.children))
        return false;
    if (data == null) {
        if (other.data != null)
            return false;
    } else if (!data.equals(other.data))
        return false;
    return true;
}