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.



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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to check if two nodes
// are in same subtrees of the root node
  
#include <iostream>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

"""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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.