# Check if two nodes are in same subtree of the root node

Given a Binary Tree with distinct nodes. Given two nodes node1 and node2, check if the two nodes lies in the same subtree of the root node. That is, either of the left and right subtrees of the root node. For Example: In the above binary tree, node 3 and 8 are in the same subtree but 4 and 5 are in different subtree.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Prerequisite: Check if a node exist in Binary Tree.

The idea is similar of searching a node in Binary Tree. There are four different cases:

1. If both node1 and node2 are in left subtree of root node.
2. If both node1 and node2 are in right subtree of the root node.
3. If node1 is in the left subtree of the root node and node2 is in the right subtree of root node.
4. If node1 is in the right subtree of the root node and node2 is in the left subtree of root node.

Use the approach of searching a node in Binary Tree and check if any of the first two cases listed above is True. If any of the first two cases listed above is found True then print YES otherwise print NO.

Below is the implementation of the above approach:

## C++

 `// C++ program to check if two nodes ` `// are in same subtrees of the root node ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Binary tree node ` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node *left, *right; ` `    ``Node(``int` `data) ` `    ``{ ` `        ``this``->data = data; ` `        ``left = right = NULL; ` `    ``} ` `}; ` ` `  `// Function to traverse the tree in preorder ` `// and check if the given node exists in ` `// a binary tree ` `bool` `ifNodeExists(``struct` `Node* node, ``int` `key) ` `{ ` `    ``if` `(node == NULL) ` `        ``return` `false``; ` ` `  `    ``if` `(node->data == key) ` `        ``return` `true``; ` ` `  `    ``/* then recur on left sutree */` `    ``bool` `res1 = ifNodeExists(node->left, key); ` ` `  `    ``/* now recur on right subtree */` `    ``bool` `res2 = ifNodeExists(node->right, key); ` ` `  `    ``return` `res1 || res2; ` `} ` ` `  `// Function to check if the two given nodes ` `// are in same subtrees of the root node ` `bool` `ifSameSubTree(Node* root, ``int` `node1, ``int` `node2) ` `{ ` `    ``if` `(root == NULL) ` `       ``return` `false``; ` ` `  `    ``// CASE 1: If both nodes are in left subtree ` `    ``if` `(ifNodeExists(root->left, node1) ` `        ``&& ifNodeExists(root->left, node2)) { ` `        ``return` `true``; ` `    ``} ` ` `  `    ``// CASE 2: If both nodes are in right subtree ` `    ``else` `if` `(ifNodeExists(root->right, node1) ` `             ``&& ifNodeExists(root->right, node2)) { ` `        ``return` `true``; ` `    ``} ` ` `  `    ``// CASE 3 and 4: Nodes are in different subtrees ` `    ``else` `        ``return` `false``; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``struct` `Node* root = ``new` `Node(0); ` `    ``root->left = ``new` `Node(1); ` `    ``root->left->left = ``new` `Node(3); ` `    ``root->left->left->left = ``new` `Node(7); ` `    ``root->left->right = ``new` `Node(4); ` `    ``root->left->right->left = ``new` `Node(8); ` `    ``root->left->right->right = ``new` `Node(9); ` `    ``root->right = ``new` `Node(2); ` `    ``root->right->left = ``new` `Node(5); ` `    ``root->right->right = ``new` `Node(6); ` ` `  `    ``int` `node1 = 3, node2 = 8; ` ` `  `    ``if` `(ifSameSubTree(root, node1, node2)) ` `        ``cout << ``"YES"``; ` `    ``else` `        ``cout << ``"NO"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to check if two nodes  ` `// are in same subtrees of the root node  ` `import` `java.util.*; ` `class` `solution ` `{ ` ` `  `// Binary tree node  ` ` ``static` `class` `Node {  ` `    ``int` `data;  ` `     ``Node left, right;  ` `    ``Node(``int` `data)  ` `    ``{  ` `        ``this``.data = data;  ` `        ``left = right = ``null``;  ` `    ``}  ` `}  ` ` `  `// Function to traverse the tree in preorder  ` `// and check if the given node exists in  ` `// a binary tree  ` `static` `boolean` `ifNodeExists( Node node, ``int` `key)  ` `{  ` `    ``if` `(node == ``null``)  ` `        ``return` `false``;  ` ` `  `    ``if` `(node.data == key)  ` `        ``return` `true``;  ` ` `  `    ``/* then recur on left sutree */` `    ``boolean` `res1 = ifNodeExists(node.left, key);  ` ` `  `    ``/* now recur on right subtree */` `    ``boolean` `res2 = ifNodeExists(node.right, key);  ` ` `  `    ``return` `res1 || res2;  ` `}  ` ` `  `// Function to check if the two given nodes  ` `// are in same subtrees of the root node  ` `static` `boolean` `ifSameSubTree(Node root, ``int` `node1, ``int` `node2)  ` `{  ` `    ``if` `(root == ``null``)  ` `    ``return` `false``;  ` ` `  `    ``// CASE 1: If both nodes are in left subtree  ` `    ``if` `(ifNodeExists(root.left, node1)  ` `        ``&& ifNodeExists(root.left, node2)) {  ` `        ``return` `true``;  ` `    ``}  ` ` `  `    ``// CASE 2: If both nodes are in right subtree  ` `    ``else` `if` `(ifNodeExists(root.right, node1)  ` `            ``&& ifNodeExists(root.right, node2)) {  ` `        ``return` `true``;  ` `    ``}  ` ` `  `    ``// CASE 3 and 4: Nodes are in different subtrees  ` `    ``else` `        ``return` `false``;  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `main(String args[]) ` `{  ` `     ``Node root = ``new` `Node(``0``);  ` `    ``root.left = ``new` `Node(``1``);  ` `    ``root.left.left = ``new` `Node(``3``);  ` `    ``root.left.left.left = ``new` `Node(``7``);  ` `    ``root.left.right = ``new` `Node(``4``);  ` `    ``root.left.right.left = ``new` `Node(``8``);  ` `    ``root.left.right.right = ``new` `Node(``9``);  ` `    ``root.right = ``new` `Node(``2``);  ` `    ``root.right.left = ``new` `Node(``5``);  ` `    ``root.right.right = ``new` `Node(``6``);  ` ` `  `    ``int` `node1 = ``3``, node2 = ``8``;  ` ` `  `    ``if` `(ifSameSubTree(root, node1, node2))  ` `        ``System.out.println(``"YES"``);  ` `    ``else` `        ``System.out.println( ``"NO"``);  ` ` `  `}  ` `} ` `//contributed by Arnab Kundu `

## Python3

 `"""Python3 program to check if two nodes  ` `are in same subtrees of the root node """` ` `  `# A Binary Tree Node  ` `# Utility function to create a  ` `# new tree node  ` `class` `newNode:  ` ` `  `    ``# Constructor to create a newNode  ` `    ``def` `__init__(``self``, data):  ` `        ``self``.data``=` `data  ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `        ``self``.visited ``=` `False` ` `  `# Function to traverse the tree in  ` `# preorder and check if the given  ` `# node exists in a binary tree  ` `def` `ifNodeExists(node, key) : ` `    ``if` `(node ``=``=` `None``): ` `        ``return` `False` ` `  `    ``if` `(node.data ``=``=` `key): ` `        ``return` `True` ` `  `    ``""" then recur on left sutree """` `    ``res1 ``=` `ifNodeExists(node.left, key)  ` ` `  `    ``""" now recur on right subtree """` `    ``res2 ``=` `ifNodeExists(node.right, key)  ` ` `  `    ``return` `res1 ``or` `res2  ` ` `  `# Function to check if the two given nodes  ` `# are in same subtrees of the root node  ` `def` `ifSameSubTree(root, node1, node2): ` ` `  `    ``if` `(root ``=``=` `None``) : ` `        ``return` `False` ` `  `    ``# CASE 1: If both nodes are in ` `    ``# left subtree  ` `    ``if` `(ifNodeExists(root.left, node1)  ` `        ``and` `ifNodeExists(root.left, node2)): ` `        ``return` `True` ` `  `    ``# CASE 2: If both nodes are in  ` `    ``# right subtree  ` `    ``elif` `(ifNodeExists(root.right, node1)  ` `            ``and` `ifNodeExists(root.right, node2)): ` `        ``return` `True` `     `  `    ``# CASE 3 and 4: Nodes are in  ` `    ``# different subtrees  ` `    ``else``: ` `        ``return` `False` `                         `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``root ``=` `newNode(``0``)  ` `    ``root.left ``=` `newNode(``1``)  ` `    ``root.left.left ``=` `newNode(``3``)  ` `    ``root.left.left.left ``=` `newNode(``7``)  ` `    ``root.left.right ``=` `newNode(``4``)  ` `    ``root.left.right.left ``=` `newNode(``8``)  ` `    ``root.left.right.right ``=` `newNode(``9``)  ` `    ``root.right ``=` `newNode(``2``)  ` `    ``root.right.left ``=` `newNode(``5``)  ` `    ``root.right.right ``=` `newNode(``6``)  ` ` `  `    ``node1 ``=` `3` `    ``node2 ``=` `8` ` `  `    ``if` `(ifSameSubTree(root, node1, node2)): ` `        ``print``(``"YES"``)  ` `    ``else``: ` `        ``print``(``"NO"``) ` ` `  `# This code is contributed by  ` `# SHUBHAMSINGH10 `

## C#

 `// C# program to check if two nodes  ` `// are in same subtrees of the root node  ` `using` `System; ` ` `  `class` `GFG ` `{  ` ` `  `// Binary tree node  ` `class` `Node ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node left, right;  ` `    ``public` `Node(``int` `data)  ` `    ``{  ` `        ``this``.data = data;  ` `        ``left = right = ``null``;  ` `    ``}  ` `}  ` ` `  `// Function to traverse the tree in preorder  ` `// and check if the given node exists in  ` `// a binary tree  ` `static` `bool` `ifNodeExists( Node node, ``int` `key)  ` `{  ` `    ``if` `(node == ``null``)  ` `        ``return` `false``;  ` ` `  `    ``if` `(node.data == key)  ` `        ``return` `true``;  ` ` `  `    ``/* then recur on left sutree */` `    ``bool` `res1 = ifNodeExists(node.left, key);  ` ` `  `    ``/* now recur on right subtree */` `    ``bool` `res2 = ifNodeExists(node.right, key);  ` ` `  `    ``return` `res1 || res2;  ` `}  ` ` `  `// Function to check if the two given nodes  ` `// are in same subtrees of the root node  ` `static` `bool` `ifSameSubTree(Node root, ` `                ``int` `node1, ``int` `node2)  ` `{  ` `    ``if` `(root == ``null``)  ` `    ``return` `false``;  ` ` `  `    ``// CASE 1: If both nodes are in left subtree  ` `    ``if` `(ifNodeExists(root.left, node1)  ` `        ``&& ifNodeExists(root.left, node2))  ` `    ``{  ` `        ``return` `true``;  ` `    ``}  ` ` `  `    ``// CASE 2: If both nodes are in right subtree  ` `    ``else` `if` `(ifNodeExists(root.right, node1)  ` `            ``&& ifNodeExists(root.right, node2))  ` `    ``{  ` `        ``return` `true``;  ` `    ``}  ` ` `  `    ``// CASE 3 and 4: Nodes are in different subtrees  ` `    ``else` `        ``return` `false``;  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `Main()  ` `{  ` `    ``Node root = ``new` `Node(0);  ` `    ``root.left = ``new` `Node(1);  ` `    ``root.left.left = ``new` `Node(3);  ` `    ``root.left.left.left = ``new` `Node(7);  ` `    ``root.left.right = ``new` `Node(4);  ` `    ``root.left.right.left = ``new` `Node(8);  ` `    ``root.left.right.right = ``new` `Node(9);  ` `    ``root.right = ``new` `Node(2);  ` `    ``root.right.left = ``new` `Node(5);  ` `    ``root.right.right = ``new` `Node(6);  ` ` `  `    ``int` `node1 = 3, node2 = 8;  ` ` `  `    ``if` `(ifSameSubTree(root, node1, node2))  ` `        ``Console.WriteLine(``"YES"``);  ` `    ``else` `        ``Console.WriteLine( ``"NO"``);  ` ` `  `}  ` `}  ` ` `  `/* This code is contributed by Rajput-Ji*/`

Output:

```YES
```

My Personal Notes arrow_drop_up Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

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