# 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
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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.

## C++

 `// C++ program to check if binary tree ` `// is subtree of another binary tree ` `#include ` `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 `

## C

 `#include ` `#include ` ` `  `/* 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; ` `} `

## Java

 `// 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 `

## Python

 `# 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) `

## C#

 `// 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*/`

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.

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.

My Personal Notes arrow_drop_up

Article Tags :

22

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.