 GFG App
Open App Browser
Continue

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

Given two binary trees, check if the first tree is a 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.

Examples:

Input:

Tree S
10
/    \
4       6
\
30

Tree T
26
/   \
10     3
/    \     \
4       6      3
\
30
Output: S is subtree of tree T

Recommended Practice

Approach:

The idea is to check at every node for the subtree.

Follow the steps below to solve the problem:

• 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.
• To check the subtree is identical or not traverse on the tree S and T simultaneously
• If a visited node is not equal then return false else continue traversing the whole tree S is traversed

Below is the implementation of above approach:

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

## Python3

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

## Javascript

 ``

Output

`Tree 2 is subtree of Tree 1`

Time Complexity: O(M*N), Traversing on subtree S of size M for every N node of Tree T.
Auxiliary space: O(n)

The above problem can be solved in O(N) time. Please refer Check if a binary tree is subtree of another binary tree | Set 2 for O(N) solution.