# Print common nodes on path from root (or common ancestors)

• Difficulty Level : Easy
• Last Updated : 23 Jan, 2022

Given a binary tree and two nodes, the task is to Print all the nodes that are common for 2 given nodes in a binary tree.

Examples:

```Given binary tree is :
1
/    \
2       3
/   \     /  \
4     5   6    7
/        /  \
8        9   10

Given nodes 9 and 7, so the common nodes are:-
1, 3```

1. Find the LCA of given two nodes.
2. Print all ancestors of the LCA as done in this post, also print the LCA.

## C++

 `// C++ Program to find common nodes for given two nodes``#include ``using` `namespace` `std;` `// A Binary Tree Node``struct` `Node {``    ``struct` `Node* left, *right;``    ``int` `key;``};` `// Utility function to create a new tree Node``Node* newNode(``int` `key)``{``    ``Node* temp = ``new` `Node;``    ``temp->key = key;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Utility function to find the LCA of two given values``// n1 and n2.``struct` `Node* findLCA(``struct` `Node* root, ``int` `n1, ``int` `n2)``{``    ``// Base case``    ``if` `(root == NULL)``        ``return` `NULL;` `    ``// If either n1 or n2 matches with root's key,``    ``// report the presence by returning root (Note``    ``// that if a key is ancestor of other, then the``    ``// ancestor key becomes LCA``    ``if` `(root->key == n1 || root->key == n2)``        ``return` `root;` `    ``// Look for keys in left and right subtrees``    ``Node* left_lca = findLCA(root->left, n1, n2);``    ``Node* right_lca = findLCA(root->right, n1, n2);` `    ``// If both of the above calls return Non-NULL, then``    ``// one key  is present in once subtree and other is``    ``// present in other, So this node is the LCA``    ``if` `(left_lca && right_lca)``        ``return` `root;` `    ``// Otherwise check if left subtree or right``    ``// subtree is LCA``    ``return` `(left_lca != NULL) ? left_lca : right_lca;``}` `// Utility Function to print all ancestors of LCA``bool` `printAncestors(``struct` `Node* root, ``int` `target)``{``    ``/* base cases */``    ``if` `(root == NULL)``        ``return` `false``;` `    ``if` `(root->key == target) {``        ``cout << root->key << ``" "``;``        ``return` `true``;``    ``}` `    ``/* If target is present in either left or right``      ``subtree of this node, then print this node */``    ``if` `(printAncestors(root->left, target) ||``        ``printAncestors(root->right, target)) {``        ``cout << root->key << ``" "``;``        ``return` `true``;``    ``}` `    ``/* Else return false */``    ``return` `false``;``}` `// Function to find nodes common to given two nodes``bool` `findCommonNodes(``struct` `Node* root, ``int` `first,``                                       ``int` `second)``{``    ``struct` `Node* LCA = findLCA(root, first, second);``    ``if` `(LCA == NULL)``        ``return` `false``;` `    ``printAncestors(root, LCA->key);``}` `// Driver program to test above functions``int` `main()``{``    ``// Let us create binary tree given in the above``    ``// example``    ``Node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(5);``    ``root->right->left = newNode(6);``    ``root->right->right = newNode(7);``    ``root->left->left->left = newNode(8);``    ``root->right->left->left = newNode(9);``    ``root->right->left->right = newNode(10);` `    ``if` `(findCommonNodes(root, 9, 7) == ``false``)``        ``cout << ``"No Common nodes"``;` `    ``return` `0;``}`

## Java

 `// Java Program to find common nodes for given two nodes``import` `java.util.LinkedList;`` ` `// Class to represent Tree node``class` `Node``{``    ``int` `data;``    ``Node left, right;`` ` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = ``null``;``        ``right = ``null``;``    ``}``}`` ` `// Class to count full nodes of Tree``class` `BinaryTree``{``    ``static` `Node root;``// Utility function to find the LCA of two given values``// n1 and n2.``static` `Node findLCA(Node root, ``int` `n1, ``int` `n2)``{``    ``// Base case``    ``if` `(root == ``null``)``        ``return` `null``;`` ` `    ``// If either n1 or n2 matches with root's key,``    ``// report the presence by returning root (Note``    ``// that if a key is ancestor of other, then the``    ``// ancestor key becomes LCA``    ``if` `(root.data == n1 || root.data == n2)``        ``return` `root;`` ` `    ``// Look for keys in left and right subtrees``    ``Node left_lca = findLCA(root.left, n1, n2);``    ``Node right_lca = findLCA(root.right, n1, n2);`` ` `    ``// If both of the above calls return Non-NULL, then``    ``// one key is present in once subtree and other is``    ``// present in other, So this node is the LCA``    ``if` `(left_lca!=``null` `&& right_lca!=``null``)``        ``return` `root;`` ` `    ``// Otherwise check if left subtree or right``    ``// subtree is LCA``    ``return` `(left_lca != ``null``) ? left_lca : right_lca;``}`` ` `// Utility Function to print all ancestors of LCA``static` `boolean` `printAncestors(Node root, ``int` `target)``{``    ``/* base cases */``    ``if` `(root == ``null``)``        ``return` `false``;`` ` `    ``if` `(root.data == target) {``        ``System.out.print(root.data+ ``" "``);``        ``return` `true``;``    ``}`` ` `    ``/* If target is present in either left or right``    ``subtree of this node, then print this node */``    ``if` `(printAncestors(root.left, target) ||``        ``printAncestors(root.right, target)) {``        ``System.out.print(root.data+ ``" "``);``        ``return` `true``;``    ``}`` ` `    ``/* Else return false */``    ``return` `false``;``}`` ` `// Function to find nodes common to given two nodes``static` `boolean` `findCommonNodes(Node root, ``int` `first,``                                    ``int` `second)``{``    ``Node LCA = findLCA(root, first, second);``    ``if` `(LCA == ``null``)``        ``return` `false``;`` ` `    ``printAncestors(root, LCA.data);``    ``return` `true``;``}`` ` `// Driver program to test above functions``    ``public` `static` `void` `main(String args[])``    ``{``    ``/*Let us create Binary Tree shown in``        ``above example */`` ` `        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(``1``);``        ``tree.root.left = ``new` `Node(``2``);``        ``tree.root.right = ``new` `Node(``3``);``        ``tree.root.left.left = ``new` `Node(``4``);``        ``tree.root.left.right = ``new` `Node(``5``);``        ``tree.root.right.left = ``new` `Node(``6``);``        ``tree.root.right.right = ``new` `Node(``7``);``        ``tree.root.left.left.left = ``new` `Node(``8``);``        ``tree.root.right.left.left = ``new` `Node(``9``);``        ``tree.root.right.left.right = ``new` `Node(``10``);`` ` `   ``if` `(findCommonNodes(root, ``9``, ``7``) == ``false``)``    ``System.out.println(``"No Common nodes"``);`` ` `    ``}``}` `// This code is contributed by Mr Somesh Awasthi`

## Python3

 `# Python3 Program to find common``# nodes for given two nodes` `# Utility class to create a new tree Node``class` `newNode:``    ``def` `__init__(``self``, key):``        ``self``.key ``=` `key``        ``self``.left ``=` `self``.right ``=` `None``    ` `# Utility function to find the LCA of``# two given values n1 and n2.``def` `findLCA(root, n1, n2):``    ` `    ``# Base case``    ``if` `(root ``=``=` `None``):``        ``return` `None` `    ``# If either n1 or n2 matches with root's key,``    ``# report the presence by returning root (Note``    ``# that if a key is ancestor of other, then the``    ``# ancestor key becomes LCA``    ``if` `(root.key ``=``=` `n1 ``or` `root.key ``=``=` `n2):``        ``return` `root` `    ``# Look for keys in left and right subtrees``    ``left_lca ``=` `findLCA(root.left, n1, n2)``    ``right_lca ``=` `findLCA(root.right, n1, n2)` `    ``# If both of the above calls return Non-None,``    ``# then one key is present in once subtree and``    ``# other is present in other, So this node is the LCA``    ``if` `(left_lca ``and` `right_lca):``        ``return` `root` `    ``# Otherwise check if left subtree or``    ``# right subtree is LCA``    ``if` `(left_lca !``=` `None``):``        ``return` `left_lca``    ``else``:``        ``return` `right_lca` `# Utility Function to print all ancestors of LCA``def` `printAncestors(root, target):``    ` `    ``# base cases``    ``if` `(root ``=``=` `None``):``        ``return` `False` `    ``if` `(root.key ``=``=` `target):``        ``print``(root.key, end ``=` `" "``)``        ``return` `True` `    ``# If target is present in either left or right``    ``# subtree of this node, then print this node``    ``if` `(printAncestors(root.left, target) ``or``        ``printAncestors(root.right, target)):``            ``print``(root.key, end ``=` `" "``)``            ``return` `True` `    ``# Else return False``    ``return` `False` `# Function to find nodes common to given two nodes``def` `findCommonNodes(root, first, second):``    ``LCA ``=` `findLCA(root, first, second)``    ``if` `(LCA ``=``=` `None``):``        ``return` `False` `    ``printAncestors(root, LCA.key)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Let us create binary tree given``    ``# in the above example``    ``root ``=` `newNode(``1``)``    ``root.left ``=` `newNode(``2``)``    ``root.right ``=` `newNode(``3``)``    ``root.left.left ``=` `newNode(``4``)``    ``root.left.right ``=` `newNode(``5``)``    ``root.right.left ``=` `newNode(``6``)``    ``root.right.right ``=` `newNode(``7``)``    ``root.left.left.left ``=` `newNode(``8``)``    ``root.right.left.left ``=` `newNode(``9``)``    ``root.right.left.right ``=` `newNode(``10``)` `    ``if` `(findCommonNodes(root, ``9``, ``7``) ``=``=` `False``):``        ``print``(``"No Common nodes"``)` `# This code is contributed by PranchalK`

## C#

 `using` `System;` `// C# Program to find common nodes for given two nodes` `// Class to represent Tree node``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = ``null``;``        ``right = ``null``;``    ``}``}` `// Class to count full nodes of Tree``public` `class` `BinaryTree``{``    ``public` `static` `Node root;``// Utility function to find the LCA of two given values``// n1 and n2.``public` `static` `Node findLCA(Node root, ``int` `n1, ``int` `n2)``{``    ``// Base case``    ``if` `(root == ``null``)``    ``{``        ``return` `null``;``    ``}` `    ``// If either n1 or n2 matches with root's key,``    ``// report the presence by returning root (Note``    ``// that if a key is ancestor of other, then the``    ``// ancestor key becomes LCA``    ``if` `(root.data == n1 || root.data == n2)``    ``{``        ``return` `root;``    ``}` `    ``// Look for keys in left and right subtrees``    ``Node left_lca = findLCA(root.left, n1, n2);``    ``Node right_lca = findLCA(root.right, n1, n2);` `    ``// If both of the above calls return Non-NULL, then``    ``// one key is present in once subtree and other is``    ``// present in other, So this node is the LCA``    ``if` `(left_lca != ``null` `&& right_lca != ``null``)``    ``{``        ``return` `root;``    ``}` `    ``// Otherwise check if left subtree or right``    ``// subtree is LCA``    ``return` `(left_lca != ``null``) ? left_lca : right_lca;``}` `// Utility Function to print all ancestors of LCA``public` `static` `bool` `printAncestors(Node root, ``int` `target)``{``    ``/* base cases */``    ``if` `(root == ``null``)``    ``{``        ``return` `false``;``    ``}` `    ``if` `(root.data == target)``    ``{``        ``Console.Write(root.data + ``" "``);``        ``return` `true``;``    ``}` `    ``/* If target is present in either left or right``    ``subtree of this node, then print this node */``    ``if` `(printAncestors(root.left, target)``    ``|| printAncestors(root.right, target))``    ``{``        ``Console.Write(root.data + ``" "``);``        ``return` `true``;``    ``}` `    ``/* Else return false */``    ``return` `false``;``}` `// Function to find nodes common to given two nodes``public` `static` `bool` `findCommonNodes(Node root,``                            ``int` `first, ``int` `second)``{``    ``Node LCA = findLCA(root, first, second);``    ``if` `(LCA == ``null``)``    ``{``        ``return` `false``;``    ``}` `    ``printAncestors(root, LCA.data);``    ``return` `true``;``}` `// Driver program to test above functions``    ``public` `static` `void` `Main(``string``[] args)``    ``{``    ``/*Let us create Binary Tree shown in``        ``above example */` `        ``BinaryTree tree = ``new` `BinaryTree();``        ``BinaryTree.root = ``new` `Node(1);``        ``BinaryTree.root.left = ``new` `Node(2);``        ``BinaryTree.root.right = ``new` `Node(3);``        ``BinaryTree.root.left.left = ``new` `Node(4);``        ``BinaryTree.root.left.right = ``new` `Node(5);``        ``BinaryTree.root.right.left = ``new` `Node(6);``        ``BinaryTree.root.right.right = ``new` `Node(7);``        ``BinaryTree.root.left.left.left = ``new` `Node(8);``        ``BinaryTree.root.right.left.left = ``new` `Node(9);``        ``BinaryTree.root.right.left.right = ``new` `Node(10);` `if` `(findCommonNodes(root, 9, 7) == ``false``)``{``    ``Console.WriteLine(``"No Common nodes"``);``}` `    ``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output:

`3 1`

This article is contributed by Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.