比較兩組二叉樹

Question

我應該創建一個equals（）方法，將兩棵樹相互比較。 不管第二棵樹的順序如何 ，如果它包含第一棵樹的所有元素，則應返回true。

我已經制作了一個equals（）方法，如果兩棵樹相同，該方法將返回true，請參見下面的代碼。 我的方法是遞歸地遍歷第二棵樹，並將其與第一棵樹的一個節點進行比較。 如果匹配，我將返回true並從我的第一棵樹繼續到另一個節點。 如果我沒有匹配就穿過第二棵樹，我將返回false。

我的比較兩個樹是否相等的代碼：

     public boolean equals(BST t) {
    return equalsTree(root, t.root);
  }

  public boolean equalsTree(Node r, Node t){
    if(r == null && t == null){
      return true; 
    }else if((r != null && t == null) || (r==null && t != null)){
      return false;
    }else{
      return t.key.equals(r.key) && (equalsTree(r.left,t.left)) && (equalsTree(r.right, t.right));
    }

  }

Answer 1

你有正確的主意。 您需要比較左右兩個分支是否匹配。 如果他們不比較相反的兩面。

|  1 | {                     |  {                     | 
|  2 |     v: 0              |      v: 0              | 
|  3 |     l: {              |      l: {              | 
|  4 |         v: 1,         |          v: 2          | 
|  5 |         l: null       |          l: null       | 
|  6 |         r: null       |          r : {         | 
|  7 |     },                |              v: 3      | 
|  8 |     r: {              |              l: null   | 
|  9 |         v: 2          |              r: null   | 
| 10 |         l: {          |          }             | 
| 11 |             v: 3      |      }                 | 
| 12 |             l: null   |       r: {             | 
| 13 |             r: null   |          v: 1          | 
| 14 |         },            |          l: null       | 
| 15 |         r: null       |          r: null       | 
| 16 |     }                 |      }                 | 
| 17 | }                     |  }                     | 

如上所示，兩個根節點的值為零，但它們的相對分支具有相同的節點。 第一棵樹的右節點（2）具有值為（3）的左節點。 第二棵樹的左側節點（2）也具有值為（3）的子節點，但它是正確的。 由於順序無關緊要，所以兩棵樹是相等的。

TreeCompare.java

public class TreeCompare {
    public static void main(String[] args) {
        Tree<Integer> treeA = new Tree<Integer>();
        Tree<Integer> treeB = new Tree<Integer>();

        Node<Integer> treeArootNode = new Node<Integer>(0);
        Node<Integer> treeBrootNode = new Node<Integer>(0);

        Node<Integer> treeAnode1 = new Node<Integer>(1);
        Node<Integer> treeAnode2 = new Node<Integer>(2);
        Node<Integer> treeAnode3 = new Node<Integer>(3);

        Node<Integer> treeBnode1 = new Node<Integer>(1);
        Node<Integer> treeBnode2 = new Node<Integer>(2);
        Node<Integer> treeBnode3 = new Node<Integer>(3);

        treeA.root = treeArootNode;
        treeB.root = treeBrootNode;

        treeA.root.left = treeAnode1;
        treeA.root.right = treeAnode2;

        treeB.root.left = treeBnode2;
        treeB.root.right = treeBnode1;

        treeAnode2.left = treeAnode3;
        treeBnode2.right = treeBnode3; // or treeBnode2.left

        System.out.println(treeA);
        System.out.println(treeB);

        System.out.println(treeA.equals(treeB));
    }
}

樹.java

public class Tree<T> {
    public Node<T> root;

    @SuppressWarnings("unchecked")
    public boolean equals(Object other) {
        Tree<T> otherTree = (Tree<T>) other;

        if (other == null) return false;
        if (this.root == null && otherTree.root != null) return false;
        if (this.root != null && otherTree.root == null) return false;

        return equalsNode(this.root, otherTree.root);
    }

    public boolean equalsNode(Node<T> nodeA, Node<T> nodeB) {
        if (nodeA == null && nodeB == null) return true;
        if (nodeA == null && nodeB != null) return false;
        if (nodeA != null && nodeB == null) return false;

        if (nodeA.equals(nodeB)) {
            if (nodeA.value == null && nodeB.value != null) return false;
            if (nodeA.value != null && nodeB.value == null) return false;

            if (nodesEqualSameLeft(nodeA, nodeB) && nodesEqualSameRight(nodeA, nodeB)) {
                return equalsNode(nodeA.left, nodeB.left) && equalsNode(nodeA.right, nodeB.right);
            }

            if (nodesEqualOppositeLeft(nodeA, nodeB) && nodesEqualOppositeRight(nodeA, nodeB)) {
                return equalsNode(nodeA.left, nodeB.right) && equalsNode(nodeA.right, nodeB.left);
            }
        }

        return false;
    }

    public boolean nodesEqualSameLeft(Node<T> nodeA, Node<T> nodeB) {
        return nodesEqual(nodeA.left, nodeB.left);
    }

    public boolean nodesEqualSameRight(Node<T> nodeA, Node<T> nodeB) {
        return nodesEqual(nodeA.right, nodeB.right);
    }

    public boolean nodesEqualOppositeLeft(Node<T> nodeA, Node<T> nodeB) {
        return nodesEqual(nodeA.left, nodeB.right);
    }

    public boolean nodesEqualOppositeRight(Node<T> nodeA, Node<T> nodeB) {
        return nodesEqual(nodeA.right, nodeB.left);
    }

    public boolean nodesEqual(Node<T> nodeA, Node<T> nodeB) {
        return (nodeA == null && nodeB == null) || (nodeA != null && nodeA.equals(nodeB));
    }

    @Override
    public String toString() {
        return root.toString();
    }
}

Node.java

public class Node<T> {
    public Node<T> left;
    public Node<T> right;
    public T value;

    public Node(Node<T> left, Node<T> right, T value) {
        this.left = left;
        this.right = right;
        this.value = value; 
    }

    public Node(T value) {
        this(null, null, value);
    }

    @Override
    @SuppressWarnings("unchecked")
    public boolean equals(Object other) {
        Node<T> otherNode = (Node<T>) other;

        if (other == null) return false;
        if (this.value == null && otherNode.value != null) return false;
        if (this.value != null && otherNode.value == null) return false;

        return this.value.equals(otherNode.value);
    }

    @Override
    public String toString() {
        return String.format("{ \"v\" : %s, \"l\" : %s, \"r\" : %s }", value, left, right);
    }
}

輸出量

{ "v" : 0, "l" : { "v" : 1, "l" : null, "r" : null }, "r" : { "v" : 2, "l" : { "v" : 3, "l" : null, "r" : null }, "r" : null } }
{ "v" : 0, "l" : { "v" : 2, "l" : null, "r" : { "v" : 3, "l" : null, "r" : null } }, "r" : { "v" : 1, "l" : null, "r" : null } }
true