Question

伙计们，我创造了两棵树。我写了一个方法，但是不能正常工作。我的方法无法递归工作，仅显示“ false”。通常，我需要遍历一棵树的元素，如果两棵树相似，则应输出-“ true”。如果两个rees不相似，则应输出-false。请帮我在树上写代码eqauls方法

我的代码：

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("NN");
        picture02.addChild("Cartoon");
        picture02.addChild("Comics");

         Tree2<String> rootFolder1 = new Tree2<>("RootFolder");
 printTree(rootFolder);
        printTree(rootFolder1);


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

        System.out.println(rootFolder.equals(rootFolder1));

    }

    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());
    }
}

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));
    }
    public boolean equals(Object obj) { 
        return isEquals(obj);
    } 

    private boolean isEquals(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;
    }
}

public class Node<T> {

    private T data;
    private final List<Node<T>> children = new ArrayList<>();
    private final Node<T> parent;

    public Node(T data, Node<T> parent) {
        this.data = data;
        this.parent = parent;
    }

    public void addChild(Node<T> node) {
        children.add(node);
    }

    public Node<T> addChild(T nodeData) {

        Node<T> newNode = new Node<T>(nodeData, this);
        children.add(newNode);
        return newNode;
    }

    public List<Node<T>> iterate() {
        return children;
    }

    public void remove(Node<T> node) {
        children.remove(node);
    }

    public List<Node<T>> getChildren() {
        return children;
    }

    public Node getParent() {
        return parent;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

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));
    }
}

Answer 1

问题是这行

if (getClass() != obj.getClass()) {
            return false;
        }

一个对象属于Tree类，另一个对象属于Tree2

Answer 2

我不知道您为什么需要两个类Tree和Tree2，但是：

TreePoint

public class TreePoint {
        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("NN");
            picture02.addChild("Cartoon");
            picture02.addChild("Comics");

            Tree2<String> rootFolder1 = new Tree2<>("RootFolder");
            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> picture011 = picture1.addChild("Picasso");
            picture011.addChild("Do Vinci");
            Node<String> picture021 = picture011.addChild("NN");
            picture021.addChild("Cartoon");
            picture021.addChild("Comics");


            printTree(rootFolder);
            printTree(rootFolder1);

            System.out.println(rootFolder.equals(rootFolder1));

        }

        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());
        }
    }

树

import java.util.List;

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));
    }

}

节点

    import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class Node<T> {

    public T data;
    public final List<Node<T>> children = new ArrayList<>();
    public final Node<T> parent;

    public Node(T data, Node<T> parent) {
        this.data = data;
        this.parent = parent;
    }

    public void addChild(Node<T> node) {
        children.add(node);
    }

    public Node<T> addChild(T nodeData) {

        Node<T> newNode = new Node<T>(nodeData, this);
        children.add(newNode);
        return newNode;
    }

    public List<Node<T>> iterate() {
        return children;
    }

    public void remove(Node<T> node) {
        children.remove(node);
    }

    public List<Node<T>> getChildren() {
        return children;
    }

    public Node getParent() {
        return parent;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        Node<?> node = (Node<?>) o;
        return Objects.equals(data, node.data) &&
                Objects.equals(children, node.children);
    }

    @Override
    public int hashCode() {
        return Objects.hash(data, children, parent);
    }
}

Tree2

import java.util.List;

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));
    }
}

两棵树中的相等方法

2 个答案: