Open In App

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