如何检查两个二叉搜索树是否具有相同的精确键（忽略值）？

Question

HOW TO IMPLEMENT LAST METHOD? I have implemented most of the beginning parts of this polymorphic binary search tree but can't figure out how to check that two trees have the same keys. Keys could be in any order but the two trees need to have identical size and identical keys (values don't matter). This method haveSameKeys returns a boolean (method at very bottom) if this has the same keys as otherTree. I first check if the trees have the same size but don't know anything further than this. I cannot use any arrays or other Java Library classes but I may add helper methods (probably recursive). Suggestions?

@SuppressWarnings("unchecked")
public class NonEmptyTree<K extends Comparable<K>, V> implements Tree<K, V> {

    public K key;
    public V value;
    public Tree<K,V> leftTree;
    public Tree<K,V> rightTree;


    public NonEmptyTree(K key, V value, Tree<K,V> leftTree, 
            Tree<K,V> rightTree) {
        this.key=key;
        this.value=value;
        this.leftTree=leftTree;
        this.rightTree=rightTree;
    }

    public NonEmptyTree<K, V> addKeyWithValue(K keyToAdd, V valueToAdd) {
       if(keyToAdd.compareTo(key)==0) {
         value = valueToAdd;
       }

       if(keyToAdd.compareTo(key)>0) {
         rightTree = rightTree.addKeyWithValue(keyToAdd, valueToAdd);
       }

       if(keyToAdd.compareTo(key)<0) {
         leftTree = leftTree.addKeyWithValue(keyToAdd, valueToAdd);
       }

       return this;
    }

    public int size() {
       return 1 + leftTree.size() + rightTree.size();
    }

    public V lookup(K lookUpKey) {
       if(lookUpKey.compareTo(key)>0) {
          return this.rightTree.lookup(lookUpKey);
       }
       if(lookUpKey.compareTo(key)<0) {
          return this.leftTree.lookup(lookUpKey);
       }
       if(lookUpKey.compareTo(key)!=0) {
          return null;
       }
       return this.value;
    }

    public K max() throws EmptyTreeException {    
       try{
          K temp = this.rightTree.max();
          return temp;
       }
       catch(EmptyTreeException e) {
          return key;
       }
    }

    public K min() throws EmptyTreeException {    
       try{
            K temp = this.leftTree.min();
            return temp;
       }
       catch(EmptyTreeException e) {
            return key;
       }
    }

    public Tree<K, V> deleteKeyAndValue(K keyToDelete) {
       if(keyToDelete.compareTo(key)>0) {
          rightTree = rightTree.deleteKeyAndValue(keyToDelete);
       }

       if(keyToDelete.compareTo(key)<0) {
          leftTree = leftTree.deleteKeyAndValue(keyToDelete);
       }

       if(keyToDelete.compareTo(key)==0) {
          try{
              value = this.lookup(rightTree.min());
              key = rightTree.min();
          }
          catch(EmptyTreeException e) {
              return this.leftTree;
          }
       }
       return this;
    }

    public boolean haveSameKeys(Tree<K, V> otherTree) { 
        boolean check = true;

        if(this.size()!=otherTree.size()) {
           check = false;
        }
    }

    // Tests haveSameKeys() with two empty trees.
    @Test public void testPublic9() {
       Tree<Byte, Boolean> tree= EmptyTree.getInstance();
       Tree<Byte, Boolean> tree2= EmptyTree.getInstance();

       assertTrue(tree.haveSameKeys(tree2));
       assertTrue(tree2.haveSameKeys(tree));
    }

    // Tests haveSameKeys() with an empty tree and a nonempty tree
    @Test public void testPublic10() {
       Tree<String, Integer> tree= EmptyTree.getInstance();
       Tree<String, Integer> tree2= TestCode.exampleTree1();

       assertFalse(tree.haveSameKeys(tree2));
       assertFalse(tree2.haveSameKeys(tree));
    }

    // Tests haveSameKeys() with two nonempty trees that have the same keys.
    @Test public void testPublic11() {
       Tree<String, Integer> tree= TestCode.exampleTree1();
       Tree<String, Integer> tree2= TestCode.exampleTree1();

       assertTrue(tree.haveSameKeys(tree2));
       assertTrue(tree2.haveSameKeys(tree));
    }

Answer 1

You can use recursion to check if every key in the tree is contained in the other tree, since lookup returns null if no such key exists.

For this, I'm making some assumptions:

• EmptyTree.haveSameKeys returns otherTree.size() == 0
• EmptyTree.hasSameKeys always returns true
• EmptyTree.lookup always returns null .

I CAN add public methods to the Tree interface that Empty/NonEmpty trees implement though if i please...

Thus, you'll need to add hasSameKeys to the Tree interface:

// Checks if every key in 'this' tree is contained in 'otherTree'
public boolean hasSameKeys(Tree<K, V> otherTree) {
    if (otherTree.lookup(this.key) == null) { // if key does not exist
        return false;
    }

    return (leftTree.hasSameKeys(otherTree) && rightTree.hasSameKeys(otherTree));
}

public boolean haveSameKeys(Tree<K, V> otherTree) { // Both trees should have the same keyset
    return hasSameKeys(otherTree) && otherTree.hasSameKeys(this); 
}

What this returns:

• EmptyTree and EmptyTree; true && true . => Empty trees have the same keyset
• NonEmptyTree and EmptyTree; false && true . => Or the other way around. Always.
• NonEmptyTree and NonEmptyTree; true => If both have the exact same key set.