Search if a binary-tree is subtree of another binary-tree

Question

I have a serious problem with recurive search of subtree in onether one.

I try this but...

public static boolean containsTree (Node t1, Node t2)
{
    if (t2 == null)
        return true;
    // Empty tree is always a subtree.
    else
        return subTree(t1, t2);
}

public static boolean subTree (Node t1, Node t2)
{
    if (t1 == null)
        return false; // Big tree is over.
    if (t1.getName().equalsIgnoreCase(t2.getName()))
        return matchTree(t1, t2);
    return (subTree(t1.getChild(), t2) || subTree(t1.getBrother(), t2));
}

private static boolean matchTree (Node t1, Node t2)
{
    if (t1 == null && t2 == null)
        return true; // Both trees are empty.
    if (t1 == null || t2 == null)
        return false; // Big tree empty and subtree still not found.
    if (!t1.getName().equalsIgnoreCase(t2.getName()))
        return false;
    return (matchTree(t1.getChild(), t2.getChild()) && matchTree(
            t1.getBrother(), t2.getBrother()));
}

seems to be not correctly formed. the containsTree function, stop to search when find a node that is different from onether one.

Below, you can find an example of two tree.

          1                 
         / \                                    3
        /   \                                   /\
       /     \                                 /  \
      2      3                                7    8
      /\     /\
     /  \   /  \
     3   4 5    6
                 \
                  3
                  /\
                 /  \
                 7   8

In this case when the function compare the subtree on the right with subtree on the left, it stop to search when find equals parent node but it have different child node. I need that the function don't stop to search but go throw this point and search for all other child node and their subtree.

Easiest way to do it is get both trees in order and then compare them. Read about [ordering](http://en.wikipedia.org/wiki/Tree_traversal#In-order_.28symmetric.29). — StackFlowed, Oct 16 '14 at 18:07
Iterator over the elements in the smaller tree and figure out if the larger tree has all of the elements. If any of the elements are not in the larger tree... It's not a subset... — Isaiah van der Elst, Oct 16 '14 at 18:12
http://stackoverflow.com/questions/21238899/why-is-inorder-and-preorder-traversel-useful-for-creating-an-algorithm-to-decide — But I'm Not A Wrapper Class, Oct 16 '14 at 18:12
he means that when it finds the first node 3 if the right or the left are different does not continue searching the subtree but discards the entire subtree — ermanno.tedeschi, Oct 16 '14 at 18:13
I don't think you can have a valid binary tree with repeating nodes. It would make searching impossible. — Isaiah van der Elst, Oct 16 '14 at 18:16
Also, the left node should be less than the root node... And the right node should be greater than the root node. — Isaiah van der Elst, Oct 16 '14 at 18:25
What is brother and child? use common names (left and right) — seteropere, Oct 16 '14 at 18:35

Soraphis · Answer 1 · 2014-10-16T18:57:39.550

say our class is like this:

class Node{
    node left, right;
    int value;    

    boolean equals(Node n){
        // if one child is null we can skip
        if(this.left == null && this.left != null ||
           this.left != null && this.left == null ){
            return false;
        }
        if(this.right == null && this.right != null ||
           this.right != null && this.right == null ){
            return false;
        }
        // 
        return (this.value == n.value) && 
               ( this.left == null || (this.left.equals(n.left)) ) && 
// if this.left == null, n.left is null too and the || will skip the equals()
               ( this.right == null || (this.right.equals(n.right)) );
// same for right
    }
}

this method will recursively check if a tree looks the same as another so, lets check if its a subtree:

boolean isSubTree(Node other){
    return this.equals(other) || 
         (other.left != null && this.isSubTree(other.left)) || 
// if left is null, this cant be a subtree 
         (other.right != null && this.isSubTree(other.right));
// same for right
}

Nothing tested but i think it could be work like this. I skipped constructors and other functions.

(bit overloaded return statements :P )

you should keep some things in your mind: trees are usually used to search for values, and are mostly implemented as binary trees were: left-child < parent < right-child

edit

obviously you should make sure that your tree does not circle :P

Search if a binary-tree is subtree of another binary-tree

1 Answers1

edit