如何编写一个递归实例方法来检查一棵二叉树在结构上是否与另一棵二叉树相同？

Question

So today my data structures final had an exam question that asked this:

"Consider the BinaryTree class and add two recursive methods (independent from each other) named compBT to compare two binary trees. If the two binary trees are structurally identical (ie, they look the same when the objects stored in the nodes are ignored), each of the two methods returns true; otherwise, each returns false. The first method should be an instance method and the second method should be a class method. Do not access the underlying data structure directly. Note: each method should not take more than 6 lines and be properly indented."

I was able to produce this for the class method:

  public static boolean compareTrees(BinaryTree t1, BinaryTree t2) {
      if (t1 == null && t2 == null) return true;
      if ((t1 == null && t2 != null) || (t1 != null && t2 == null)) return false;

      return compareTrees(t1.left, t2.left) && compareTrees(t1.right, t2.right);
  }

I felt pretty confident about this answer, but writing the instance method had me totally stumped, especially since it had to be independent from the class method. All I was able to produce was the following:

public boolean compareTrees(BinaryTree t) {
    if (t == null) return false;
    return (compareTrees(this.left) && (t.left)) && (compareTrees(this.right) && compareTrees(t.right));
}

I know the method is incorrect since it will always return false because there is only one base case which will always be met. My thought process behind that particular base case is that if the parameter is null, then return false since there is a structural inequality because the caller cannot be null (only non-null references can call instance methods). But I didn't know what else to do from there.

Can anyone chime in? I thought this problem was pretty interesting.

Edit: adding in BinaryTree class.

Here's what the BinaryTree class looked like:

class BinaryTree {
    public int value;
    public BinaryTree left;
    public BinaryTree right;

    public BinaryTree(int x) { value = x;}
}

Answer 1

I think you've recognized the basic problem. In your static method, you can pass null for both child trees when you call the method recursively. But in your instance method, you can only do that for the parameter. You can't do that for the instance method, since you can't call an instance method on null .

Well, if you can't call the instance method recursively on a null child, you have to handle the null child case before the recursive call. That's the key here, the realization that you will have to rearrange your logic. So your logic will need to be something like this:

1. If the parameter is null, return false (like you already did)

2. If the instance's left child is null, then:

   2.1 If the parameter's left child is not null, return false

   2.2 If the parameter's left child is null, keep going with step 4

3. If the instance's left child is not null, then call recursively on the left child (it doesn't matter if the parameter's left child is null, because that will be caught be #1), and return false if the recursive call returns false

4-5. Same steps for the right child

6. If we've gotten this far, and no check has failed, then we can return true

So the code looks something like this:

  public boolean compareTrees(BinaryTree t) {
      if (t == null) return false;
      if (this.left == null) {
          if (t.left != null) {
              return false;
          }
      } 
      else if (!this.left.compareTrees(t.left)) {
          return false;
      }
      if (this.right == null) {
          if (t.right != null) {
              return false;
          }
      } 
      else if (!this.right.compareTrees(t.right)) {
          return false;
      }
      return true;
  }

I just now noticed the requirement that the method not be more than 6 lines. So I guess my answer won't work. On the other hand, I could make it work by compressing a bunch of stuff onto a few lines.

  public boolean compareTrees(BinaryTree t) {
      if (t == null) return false;
      if (this.left == null && t.left != null) return false;
      if (this.left != null && !this.left.compareTrees(t.left)) return false;
      if (this.right == null && t.right != null) return false;
      if (this.right != null && !this.right.compareTrees(t.right)) return false;
      return true;
  }

I could make it even shorter by combining the last two lines into one. But if your professor is going to reward compressed, harder-to-read code such as this, and fail cleaner code like I had in my earlier example, shame on him.

OK, if your professor measures code quality by a smaller number of lines, this should make him ecstatic, even though all my colleagues would blast it in a code review:

  public boolean compareTrees(BinaryTree t) {
      return !((t == null) || (this.left == null && t.left != null) ||  (this.left != null && !this.left.compareTrees(t.left)) || (this.right == null && t.right != null) || (this.right != null && !this.right.compareTrees(t.right)) );
  }

Answer 2

For instance method, all that changes is that check is before recursion, no in it:

  public boolean compareTrees(BinaryTree other) {

      if (left == null) != (other.left == null) return false;
      if (right == null) != (other.right == null) return false;

      if (left != null && !left.compareTrees(other.left)) return false;
      if (right != null && !right.compareTrees(other.right)) return false;

      return true;
  }