Check if a binary tree is subtree of another binary tree | Set 1

Given two binary trees, check if the first tree is subtree of the second one. A subtree of a tree T is a tree S consisting of a node in T and all of its descendants in T. The subtree corresponding to the root node is the entire tree; the subtree corresponding to any other node is called a proper subtree.

For example, in the following case, tree S is a subtree of tree T.

        Tree 2
          10  
        /    \ 
      4       6
       \
        30


        Tree 1
              26
            /   \
          10     3
        /    \     \
      4       6      3
       \
        30

Solution: Traverse the tree T in preorder fashion. For every visited node in the traversal, see if the subtree rooted with this node is identical to S.

Following is the implementation for this.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to check if binary tree
// is subtree of another binary tree
#include<bits/stdc++.h>
using namespace std;
  
/* A binary tree node has data, 
left child and right child */
class node 
    public:
    int data; 
    node* left; 
    node* right; 
}; 
  
/* A utility function to check 
whether trees with roots as root1 and 
root2 are identical or not */
bool areIdentical(node * root1, node *root2) 
    /* base cases */
    if (root1 == NULL && root2 == NULL) 
        return true
  
    if (root1 == NULL || root2 == NULL) 
        return false
  
    /* Check if the data of both roots is 
    same and data of left and right 
    subtrees are also same */
    return (root1->data == root2->data && 
            areIdentical(root1->left, root2->left) && 
            areIdentical(root1->right, root2->right) ); 
  
  
/* This function returns true if S 
is a subtree of T, otherwise false */
bool isSubtree(node *T, node *S) 
    /* base cases */
    if (S == NULL) 
        return true
  
    if (T == NULL) 
        return false
  
    /* Check the tree with root as current node */
    if (areIdentical(T, S)) 
        return true
  
    /* If the tree with root as current 
    node doesn't match then try left 
    and right subtrees one by one */
    return isSubtree(T->left, S) || 
        isSubtree(T->right, S); 
  
  
/* Helper function that allocates 
a new node with the given data 
and NULL left and right pointers. */
node* newNode(int data) 
    node* Node = new node(); 
    Node->data = data; 
    Node->left = NULL; 
    Node->right = NULL; 
    return(Node); 
  
/* Driver code*/
int main() 
    // TREE 1 
    /* Construct the following tree 
            26 
            / \ 
        10 3 
        / \ \ 
    4 6 3 
    
        30 
    */
    node *T = newNode(26); 
    T->right         = newNode(3); 
    T->right->right = newNode(3); 
    T->left         = newNode(10); 
    T->left->left     = newNode(4); 
    T->left->left->right = newNode(30); 
    T->left->right     = newNode(6); 
  
    // TREE 2 
    /* Construct the following tree 
        10 
        / \ 
    4 6 
    
        30 
    */
    node *S = newNode(10); 
    S->right     = newNode(6); 
    S->left     = newNode(4); 
    S->left->right = newNode(30); 
  
  
    if (isSubtree(T, S)) 
        cout << "Tree 2 is subtree of Tree 1"
    else
        cout << "Tree 2 is not a subtree of Tree 1"
  
    return 0; 
  
// This code is contributed by rathbhupendra
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

#include <stdio.h>
#include <stdlib.h>
  
/* A binary tree node has data, left child and right child */
struct node
{
    int data;
    struct node* left;
    struct node* right;
};
  
/* A utility function to check whether trees with roots as root1 and
   root2 are identical or not */
bool areIdentical(struct node * root1, struct node *root2)
{
    /* base cases */
    if (root1 == NULL && root2 == NULL)
        return true;
  
    if (root1 == NULL || root2 == NULL)
        return false;
  
    /* Check if the data of both roots is same and data of left and right
       subtrees are also same */
    return (root1->data == root2->data   &&
            areIdentical(root1->left, root2->left) &&
            areIdentical(root1->right, root2->right) );
}
  
  
/* This function returns true if S is a subtree of T, otherwise false */
bool isSubtree(struct node *T, struct node *S)
{
    /* base cases */
    if (S == NULL)
        return true;
  
    if (T == NULL)
        return false;
  
    /* Check the tree with root as current node */
    if (areIdentical(T, S))
        return true;
  
    /* If the tree with root as current node doesn't match then
       try left and right subtrees one by one */
    return isSubtree(T->left, S) ||
           isSubtree(T->right, S);
}
  
  
/* Helper function that allocates a new node with the given data
   and NULL left and right pointers. */
struct node* newNode(int data)
{
    struct node* node =
        (struct node*)malloc(sizeof(struct node));
    node->data  = data;
    node->left  = NULL;
    node->right = NULL;
    return(node);
}
  
/* Driver program to test above function */
int main()
{
    // TREE 1
    /* Construct the following tree
              26
            /   \
          10     3
        /    \     \
      4      6      3
       \
        30
    */
    struct node *T        = newNode(26);
    T->right              = newNode(3);
    T->right->right       = newNode(3);
    T->left               = newNode(10);
    T->left->left         = newNode(4);
    T->left->left->right  = newNode(30);
    T->left->right        = newNode(6);
  
    // TREE 2
    /* Construct the following tree
          10
        /    \
      4      6
       \
        30
    */
    struct node *S    = newNode(10);
    S->right          = newNode(6);
    S->left           = newNode(4);
    S->left->right    = newNode(30);
  
  
    if (isSubtree(T, S))
        printf("Tree 2 is subtree of Tree 1");
    else
        printf("Tree 2 is not a subtree of Tree 1");
  
    getchar();
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to check if binary tree is subtree of another binary tree
   
// A binary tree node
class Node 
{
    int data;
    Node left, right, nextRight;
   
    Node(int item) 
    {
        data = item;
        left = right = nextRight = null;
    }
}
   
class BinaryTree 
{
    Node root1,root2;
   
    /* A utility function to check whether trees with roots as root1 and
       root2 are identical or not */
    boolean areIdentical(Node root1, Node root2) 
    {
   
        /* base cases */
        if (root1 == null && root2 == null)
            return true;
   
        if (root1 == null || root2 == null)
            return false;
   
        /* Check if the data of both roots is same and data of left and right
           subtrees are also same */
        return (root1.data == root2.data
                && areIdentical(root1.left, root2.left)
                && areIdentical(root1.right, root2.right));
    }
   
    /* This function returns true if S is a subtree of T, otherwise false */
    boolean isSubtree(Node T, Node S) 
    {
        /* base cases */
        if (S == null
            return true;
   
        if (T == null)
            return false;
   
        /* Check the tree with root as current node */
        if (areIdentical(T, S)) 
            return true;
   
        /* If the tree with root as current node doesn't match then
           try left and right subtrees one by one */
        return isSubtree(T.left, S)
                || isSubtree(T.right, S);
    }
   
    public static void main(String args[]) 
    {
        BinaryTree tree = new BinaryTree();
           
        // TREE 1
        /* Construct the following tree
              26
             /   \
            10     3
           /    \     \
          4      6      3
           \
            30  */
            
        tree.root1 = new Node(26);
        tree.root1.right = new Node(3);
        tree.root1.right.right = new Node(3);
        tree.root1.left = new Node(10);
        tree.root1.left.left = new Node(4);
        tree.root1.left.left.right = new Node(30);
        tree.root1.left.right = new Node(6);
   
        // TREE 2
        /* Construct the following tree
           10
         /    \
         4      6
          \
          30  */
            
        tree.root2 = new Node(10);
        tree.root2.right = new Node(6);
        tree.root2.left = new Node(4);
        tree.root2.left.right = new Node(30);
   
        if (tree.isSubtree(tree.root1, tree.root2))
            System.out.println("Tree 2 is subtree of Tree 1 ");
        else
            System.out.println("Tree 2 is not a subtree of Tree 1");
    }
}
   
// This code has been contributed by Mayank Jaiswal
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to check binary tree is a subtree of 
# another tree
  
# A binary tree node
class Node:
  
    # Constructor to create a new node
    def __init__(self, data):
        self.data = data 
        self.left = None
        self.right = None
  
# A utility function to check whether trees with roots
# as root 1 and root2 are indetical or not
def areIdentical(root1, root2):
      
    # Base Case
    if root1 is None and root2 is None:
        return True
    if root1 is None or root2 is None:
        return False
  
    # Check fi the data of both roots is same and data of
    # left and right subtrees are also same
    return (root1.data == root2.data and 
            areIdentical(root1.left , root2.left)and
            areIdentical(root1.right, root2.right)
            
  
# This function returns True if S is a subtree of T,
# otherwise False
def isSubtree(T, S):
      
    # Base Case
    if S is None:
        return True
  
    if T is None:
        return False
  
    # Check the tree with root as current node
    if (areIdentical(T, S)):
        return True
  
    # IF the tree with root as current node doesn't match
    # then try left and right subtreee one by one
    return isSubtree(T.left, S) or isSubtree(T.right, S)
  
  
# Driver program to test above function
  
""" TREE 1
     Construct the following tree
              26
            /   \
          10     3
        /    \     \
      4      6      3
       \
        30
    """
  
T = Node(26)
T.right = Node(3)
T.right.right  = Node(3)
T.left = Node(10)
T.left.left = Node(4)
T.left.left.right = Node(30)
T.left.right = Node(6)
  
""" TREE 2
     Construct the following tree
          10
        /    \
      4      6
       \
        30
    """
S = Node(10)
S.right = Node(6)
S.left = Node(4)
S.left.right = Node(30)
  
if isSubtree(T, S):
    print "Tree 2 is subtree of Tree 1"
else :
    print "Tree 2 is not a subtree of Tree 1"
  
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to check if binary tree 
// is subtree of another binary tree 
using System;
  
// A binary tree node 
class Node 
    public int data; 
    public Node left, right, nextRight; 
  
    public Node(int item) 
    
        data = item; 
        left = right = nextRight = null
    
  
public class BinaryTree 
    Node root1,root2; 
  
    /* A utility function to check whether
        trees with roots as root1 and 
        root2 are identical or not */
    bool areIdentical(Node root1, Node root2) 
    
  
        /* base cases */
        if (root1 == null && root2 == null
            return true
  
        if (root1 == null || root2 == null
            return false
  
        /* Check if the data of both roots is
        same and data of left and right 
        subtrees are also same */
        return (root1.data == root2.data 
                && areIdentical(root1.left, root2.left) 
                && areIdentical(root1.right, root2.right)); 
    
  
    /* This function returns true if S is 
    a subtree of T, otherwise false */
    bool isSubtree(Node T, Node S) 
    
        /* base cases */
        if (S == null
            return true
  
        if (T == null
            return false
  
        /* Check the tree with root as current node */
        if (areIdentical(T, S)) 
            return true
  
        /* If the tree with root as current 
          node doesn't match then try left
          and right subtrees one by one */
        return isSubtree(T.left, S) 
                || isSubtree(T.right, S); 
    
  
    // Driver code
    public static void Main() 
    
        BinaryTree tree = new BinaryTree(); 
          
        // TREE 1 
        /* Construct the following tree 
            26 
            / \ 
            10 3 
        / \ \ 
        4 6 3 
        
            30 */
              
        tree.root1 = new Node(26); 
        tree.root1.right = new Node(3); 
        tree.root1.right.right = new Node(3); 
        tree.root1.left = new Node(10); 
        tree.root1.left.left = new Node(4); 
        tree.root1.left.left.right = new Node(30); 
        tree.root1.left.right = new Node(6); 
  
        // TREE 2 
        /* Construct the following tree 
        10 
        / \ 
        4 6 
        
        30 */
              
        tree.root2 = new Node(10); 
        tree.root2.right = new Node(6); 
        tree.root2.left = new Node(4); 
        tree.root2.left.right = new Node(30); 
  
        if (tree.isSubtree(tree.root1, tree.root2)) 
            Console.WriteLine("Tree 2 is subtree of Tree 1 "); 
        else
            Console.WriteLine("Tree 2 is not a subtree of Tree 1"); 
    
  
/* This code is contributed by Rajput-Ji*/
chevron_right


Output:

Tree 2 is subtree of Tree 1 

Time Complexity: Time worst case complexity of above solution is O(mn) where m and n are number of nodes in given two trees.

We can solve the above problem in O(n) time. Please refer Check if a binary tree is subtree of another binary tree | Set 2 for O(n) solution.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.





Article Tags :