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