# Print Common Nodes in Two Binary Search Trees

Given two Binary Search Trees, find common nodes in them. In other words, find the intersection of two BSTs.

Example:

Input: root1:
5
/          \
1              10
/      \          /
0        4       7
\
9

root2:    10
/       \
7         20
/      \
4          9
Output: 4 7 9 10

Recommended Practice

Naive Approach:

A simple way is to one by one search every node of the first tree in the second tree.

Time Complexity: O(M * H) where M is the number of nodes in the first tree and H is the height of the second tree.
Auxiliary Space: O(1)

## Common Nodes in Two Binary Search Trees using Inorder and Intersection:

The idea is simply to take the inorder traversal of both the trees and store them in two separate arrays and then find the intersection between two arrays.

Follow the steps below to solve the problem:

• Do inorder traversal of the first tree and store the traversal in an auxiliary array ar1[]. See sortedInorder() here
• Do inorder traversal of the second tree and store the traversal in an auxiliary array ar2[]
• Find intersection of ar1[] and ar2[].

Below is the implementation of the above approach:

## C++

 `// C++ program of iterative traversal based method to` `// find common elements in two BSTs.`   `#include ` `#include ` `#include ` `using` `namespace` `std;`   `// A BST node` `struct` `Node {` `    ``int` `key;` `    ``struct` `Node *left, *right;` `};`   `// A utility function to create a new node` `Node* newNode(``int` `ele)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = ele;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// A utility function to do inorder traversal` `void` `inorder(``struct` `Node* root, vector<``int``> &traversal)` `{` `    ``if` `(root) {` `        ``inorder(root->left, traversal);` `        ``traversal.push_back(root->key);` `        ``inorder(root->right, traversal);` `    ``}` `}`   `// Function two print common elements in given two trees` `void` `printCommon(Node* root1, Node* root2)` `{` `    ``vector<``int``> inorder1, inorder2;` `    ``// Storing inorder traversal of both the trees` `    ``inorder(root1, inorder1);` `    ``inorder(root2, inorder2);` `    `  `    ``cout << ``"Tree 1 : "` `<< endl;` `    ``for``(``int` `i = 0; i < inorder1.size(); i++){` `        ``cout << inorder1[i] << ``" "``;` `    ``}` `    ``cout << endl;` `    `  `    ``cout << ``"Tree 2 : "` `<< endl;` `    ``for``(``int` `i = 0; i < inorder2.size(); i++){` `        ``cout << inorder2[i] << ``" "``;` `    ``}` `    ``cout << endl;` `    `  `    ``cout << ``"Common Nodes: "` `<< endl;` `    `  `    ``// Using two pointers calculating common nodes in both the traversals` `    ``int` `i = 0, j = 0;` `    ``while``(i < inorder1.size() && j < inorder2.size()){` `        ``if``(inorder1[i] == inorder2[j]){` `            ``cout << inorder1[i] << ``" "``;` `            ``i++;` `            ``j++;` `        ``}` `        ``else` `if``(inorder1[i] < inorder2[j]){` `            ``i++;` `        ``}` `        ``else``{` `            ``j++;` `        ``}` `    ``}` `}`   `// A utility function to insert a new Node ` `// with given key in BST` `struct` `Node* insert(``struct` `Node* node, ``int` `key)` `{` `    ``// If the tree is empty, return a new Node` `    ``if` `(node == NULL)` `        ``return` `newNode(key);`   `    ``// Otherwise, recur down the tree` `    ``if` `(key < node->key)` `        ``node->left = insert(node->left, key);` `    ``else` `if` `(key > node->key)` `        ``node->right = insert(node->right, key);`   `    ``// Return the (unchanged) Node pointer` `    ``return` `node;` `}`   `// Driver program` `int` `main()` `{` `    ``// Create first tree as shown in example` `    ``Node* root1 = NULL;` `    ``root1 = insert(root1, 5);` `    ``root1 = insert(root1, 1);` `    ``root1 = insert(root1, 10);` `    ``root1 = insert(root1, 0);` `    ``root1 = insert(root1, 4);` `    ``root1 = insert(root1, 7);` `    ``root1 = insert(root1, 9);`   `    ``// Create second tree as shown in example` `    ``Node* root2 = NULL;` `    ``root2 = insert(root2, 10);` `    ``root2 = insert(root2, 7);` `    ``root2 = insert(root2, 20);` `    ``root2 = insert(root2, 4);` `    ``root2 = insert(root2, 9);`   `    ``printCommon(root1, root2);`   `    ``return` `0;` `}`

## Java

 `//Java code for the above approach` `import` `java.util.*;`   `class` `Node {` `    ``int` `key;` `    ``Node left, right;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``key = item;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTree {`   `    ``Node root1, root2;`   `    ``// A utility function to do inorder traversal` `    ``void` `inorder(Node root, ArrayList traversal)` `    ``{` `        ``if` `(root != ``null``) {` `            ``inorder(root.left, traversal);` `            ``traversal.add(root.key);` `            ``inorder(root.right, traversal);` `        ``}` `    ``}`   `    ``// Function two print common elements in given two trees` `    ``void` `printCommon()` `    ``{` `        ``ArrayList inorder1` `            ``= ``new` `ArrayList();` `        ``ArrayList inorder2` `            ``= ``new` `ArrayList();` `        ``// Storing inorder traversal of both the trees` `        ``inorder(root1, inorder1);` `        ``inorder(root2, inorder2);`   `        ``System.out.println(``"Tree 1 : "``);` `        ``for` `(``int` `i = ``0``; i < inorder1.size(); i++) {` `            ``System.out.print(inorder1.get(i) + ``" "``);` `        ``}` `        ``System.out.println();`   `        ``System.out.println(``"Tree 2 : "``);` `        ``for` `(``int` `i = ``0``; i < inorder2.size(); i++) {` `            ``System.out.print(inorder2.get(i) + ``" "``);` `        ``}` `        ``System.out.println();`   `        ``System.out.println(``"Common Nodes: "``);`   `        ``// Using two pointers calculating common nodes in` `        ``// both the traversals` `        ``int` `i = ``0``, j = ``0``;` `        ``while` `(i < inorder1.size() && j < inorder2.size()) {` `            ``if` `(inorder1.get(i) == inorder2.get(j)) {` `                ``System.out.print(inorder1.get(i) + ``" "``);` `                ``i++;` `                ``j++;` `            ``}` `            ``else` `if` `(inorder1.get(i) < inorder2.get(j)) {` `                ``i++;` `            ``}` `            ``else` `{` `                ``j++;` `            ``}` `        ``}` `    ``}`   `    ``// A utility function to insert a new Node` `    ``// with given key in BST` `    ``Node insert(Node node, ``int` `key)` `    ``{` `        ``// If the tree is empty, return a new Node` `        ``if` `(node == ``null``) {` `            ``return` `new` `Node(key);` `        ``}`   `        ``// Otherwise, recur down the tree` `        ``if` `(key < node.key) {` `            ``node.left = insert(node.left, key);` `        ``}` `        ``else` `if` `(key > node.key) {` `            ``node.right = insert(node.right, key);` `        ``}`   `        ``// Return the (unchanged) Node pointer` `        ``return` `node;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();`   `        ``// Create first tree as shown in example` `        ``tree.root1 = tree.insert(tree.root1, ``5``);` `        ``tree.root1 = tree.insert(tree.root1, ``1``);` `        ``tree.root1 = tree.insert(tree.root1, ``10``);` `        ``tree.root1 = tree.insert(tree.root1, ``0``);` `        ``tree.root1 = tree.insert(tree.root1, ``4``);` `        ``tree.root1 = tree.insert(tree.root1, ``7``);` `        ``tree.root1 = tree.insert(tree.root1, ``9``);`   `        ``// Create second tree as shown in example` `        ``tree.root2 = tree.insert(tree.root2, ``10``);` `        ``tree.root2 = tree.insert(tree.root2, ``7``);` `        ``tree.root2 = tree.insert(tree.root2, ``20``);` `        ``tree.root2 = tree.insert(tree.root2, ``4``);` `        ``tree.root2 = tree.insert(tree.root2, ``9``);`   `        ``tree.printCommon();` `    ``}` `}`

## Python3

 `# Python program of iterative traversal based method to` `# find common elements in two BSTs.`   `# A BST node` `class` `Node:` `    `  `    ``def` `__init__(``self``):` `        ``self``.key ``=` `0``;` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# A utility function to create a new node` `def` `newNode(ele):` `    ``temp ``=` `Node()` `    ``temp.key ``=` `ele` `    ``temp.left ``=` `temp.right ``=` `None` `    ``return` `temp`   `# A utility function to do inorder traversal` `def` `inorder(root, traversal):` `    ``if` `root !``=` `None``:` `        ``inorder(root.left, traversal)` `        ``traversal.append(root.key)` `        ``inorder(root.right, traversal)`     `# Function two print common elements in given two trees` `def` `printCommon(root1, root2):` `        `  `    ``inorder1 ``=` `[]` `    ``inorder2 ``=` `[]` `    `  `    ``# Storing inorder traversal of both the trees` `    ``inorder(root1, inorder1)` `    ``inorder(root2, inorder2)` `    `  `    ``print``(``"Tree 1 : "``)` `    ``for` `i ``in` `range``(``len``(inorder1)):` `        ``print``(inorder1[i], end ``=` `" "``)`   `    ``print``()` `    `  `    ``print``(``"Tree 2 : "``)` `    ``for` `i ``in` `range``(``len``(inorder2)):` `        ``print``(inorder2[i], end ``=` `" "``)`   `    ``print``()` `    `  `    ``print``(``"Common Nodes: "``)` `    `  `    ``# Using two pointers calculating common nodes in both the traversals` `    ``i ``=` `0` `    ``j ``=` `0` `    ``while``(i < ``len``(inorder1) ``and` `j < ``len``(inorder2)):` `        ``if``(inorder1[i] ``=``=` `inorder2[j]):` `            ``print``(inorder1[i], end ``=` `" "``)` `            ``i ``=` `i ``+` `1` `            ``j ``=` `j ``+` `1` `        `  `        ``elif` `inorder1[i] < inorder2[j]:` `            ``i ``=` `i ``+` `1` `        ``else``:` `            ``j ``=` `j ``+` `1` `            `  `    ``print``()` `    `    `# A utility function to insert a new Node ` `# with given key in BST` `def` `insert(node, key):` `    ``# If the tree is empty, return a new Node` `    ``if` `(node ``=``=` `None``):` `        ``return` `newNode(key)`   `    ``# Otherwise, recur down the tree` `    ``if` `(key < node.key):` `        ``node.left ``=` `insert(node.left, key)` `    ``elif` `key > node.key:` `        ``node.right ``=` `insert(node.right, key)`   `    ``# Return the (unchanged) Node pointer` `    ``return` `node`   `# Driver program` `# Create first tree as shown in example` `root1 ``=` `None` `root1 ``=` `insert(root1, ``5``)` `root1 ``=` `insert(root1, ``1``)` `root1 ``=` `insert(root1, ``10``)` `root1 ``=` `insert(root1, ``0``)` `root1 ``=` `insert(root1, ``4``)` `root1 ``=` `insert(root1, ``7``)` `root1 ``=` `insert(root1, ``9``)`   `# Create second tree as shown in example` `root2 ``=` `None` `root2 ``=` `insert(root2, ``10``)` `root2 ``=` `insert(root2, ``7``)` `root2 ``=` `insert(root2, ``20``)` `root2 ``=` `insert(root2, ``4``)` `root2 ``=` `insert(root2, ``9``)`   `printCommon(root1, root2)`   `# The code is contributed by Nidhi goel. `

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `Node` `{` `    ``public` `int` `key;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``key = item;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTree` `{` `    ``public` `Node root1, root2;`   `    ``// A utility function to do inorder traversal` `    ``void` `Inorder(Node root, List<``int``> traversal)` `    ``{` `        ``if` `(root != ``null``)` `        ``{` `            ``Inorder(root.left, traversal);` `            ``traversal.Add(root.key);` `            ``Inorder(root.right, traversal);` `        ``}` `    ``}`   `    ``// Function to print common elements in given two trees` `    ``public` `void` `PrintCommon()` `    ``{` `        ``List<``int``> inorder1 = ``new` `List<``int``>();` `        ``List<``int``> inorder2 = ``new` `List<``int``>();` `        ``// Storing inorder traversal of both the trees` `        ``Inorder(root1, inorder1);` `        ``Inorder(root2, inorder2);`   `        ``Console.WriteLine(``"Tree 1 : "``);` `        ``foreach` `(``int` `p ``in` `inorder1)` `        ``{` `            ``Console.Write(p + ``" "``);` `        ``}` `        ``Console.WriteLine();`   `        ``Console.WriteLine(``"Tree 2 : "``);` `        ``foreach` `(``int` `k ``in` `inorder2)` `        ``{` `            ``Console.Write(k+ ``" "``);` `        ``}` `        ``Console.WriteLine();`   `        ``Console.WriteLine(``"Common Nodes: "``);`   `        ``// Using two pointers to calculate common nodes in` `        ``// both the traversals` `        ``int` `i = 0, j = 0;` `        ``while` `(i < inorder1.Count && j < inorder2.Count)` `        ``{` `            ``if` `(inorder1[i] == inorder2[j])` `            ``{` `                ``Console.Write(inorder1[i] + ``" "``);` `                ``i++;` `                ``j++;` `            ``}` `            ``else` `if` `(inorder1[i] < inorder2[j])` `            ``{` `                ``i++;` `            ``}` `            ``else` `            ``{` `                ``j++;` `            ``}` `        ``}` `    ``}`   `    ``// A utility function to insert a new Node` `    ``// with given key in BST` `    ``public` `Node Insert(Node node, ``int` `key)` `    ``{` `        ``// If the tree is empty, return a new Node` `        ``if` `(node == ``null``)` `        ``{` `            ``return` `new` `Node(key);` `        ``}`   `        ``// Otherwise, recur down the tree` `        ``if` `(key < node.key)` `        ``{` `            ``node.left = Insert(node.left, key);` `        ``}` `        ``else` `if` `(key > node.key)` `        ``{` `            ``node.right = Insert(node.right, key);` `        ``}`   `        ``// Return the (unchanged) Node pointer` `        ``return` `node;` `    ``}` `static` `void` `Main(``string``[] args)` `{` `    ``BinaryTree tree = ``new` `BinaryTree();`   `    ``// Create first tree as shown in example` `    ``tree.root1 = tree.Insert(tree.root1, 5);` `    ``tree.root1 = tree.Insert(tree.root1, 1);` `    ``tree.root1 = tree.Insert(tree.root1, 10);` `    ``tree.root1 = tree.Insert(tree.root1, 0);` `    ``tree.root1 = tree.Insert(tree.root1, 4);` `    ``tree.root1 = tree.Insert(tree.root1, 7);` `    ``tree.root1 = tree.Insert(tree.root1, 9);`   `    ``// Create second tree as shown in example` `    ``tree.root2 = tree.Insert(tree.root2, 10);` `    ``tree.root2 = tree.Insert(tree.root2, 7);` `    ``tree.root2 = tree.Insert(tree.root2, 20);` `    ``tree.root2 = tree.Insert(tree.root2, 4);` `    ``tree.root2 = tree.Insert(tree.root2, 9);`   `    ``tree.PrintCommon();` `}` `}` ` `

## Javascript

 `// javascript program of iterative traversal based method to` `// find common elements in two BSTs.`   `// A BST node` `class Node {` `    ``constructor(){` `        ``this``.key = 0;` `        ``this``.left = ``null` `        ``this``.right = ``null` `    ``}` `}`   `// A utility function to create a new node` `function` `newNode(ele)` `{` `    ``let temp = ``new` `Node();` `    ``temp.key = ele;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `}`   `// A utility function to do inorder traversal` `function` `inorder(root, traversal)` `{` `    ``if` `(root != ``null``) {` `        ``inorder(root.left, traversal);` `        ``traversal.push(root.key);` `        ``inorder(root.right, traversal);` `    ``}` `}`   `// Function two print common elements in given two trees` `function` `printCommon(root1, root2)` `{` `    ``let inorder1 = ``new` `Array();` `    ``let inorder2 = ``new` `Array();` `    `  `    ``// Storing inorder traversal of both the trees` `    ``inorder(root1, inorder1);` `    ``inorder(root2, inorder2);` `    `  `    ``console.log(``"Tree 1 : \n"``);` `    ``for``(let i = 0; i < inorder1.length; i++){` `        ``console.log(inorder1[i] + ``" "``);` `    ``}` `    ``console.log(``"\n"``);` `    `  `    ``console.log(``"Tree 2 : "``);` `    ``for``(let i = 0; i < inorder2.length; i++){` `        ``console.log(inorder2[i] + ``" "``);` `    ``}` `    ``console.log(``"\n"``);` `    `  `    ``console.log(``"Common Nodes: \n"``);` `    `  `    ``// Using two pointers calculating common nodes in both the traversals` `    ``let i = 0, j = 0;` `    ``while``(i < inorder1.length && j < inorder2.length){` `        ``if``(inorder1[i] == inorder2[j]){` `            ``console.log(inorder1[i] + ``" "``);` `            ``i++;` `            ``j++;` `        ``}` `        ``else` `if``(inorder1[i] < inorder2[j]){` `            ``i++;` `        ``}` `        ``else``{` `            ``j++;` `        ``}` `    ``}` `}`   `// A utility function to insert a new Node ` `// with given key in BST` `function` `insert(node, key)` `{` `    ``// If the tree is empty, return a new Node` `    ``if` `(node == ``null``)` `        ``return` `newNode(key);`   `    ``// Otherwise, recur down the tree` `    ``if` `(key < node.key)` `        ``node.left = insert(node.left, key);` `    ``else` `if` `(key > node.key)` `        ``node.right = insert(node.right, key);`   `    ``// Return the (unchanged) Node pointer` `    ``return` `node;` `}`   `// Driver program` `// Create first tree as shown in example` `let root1 = ``null``;` `root1 = insert(root1, 5);` `root1 = insert(root1, 1);` `root1 = insert(root1, 10);` `root1 = insert(root1, 0);` `root1 = insert(root1, 4);` `root1 = insert(root1, 7);` `root1 = insert(root1, 9);`   `// Create second tree as shown in example` `let root2 = ``null``;` `root2 = insert(root2, 10);` `root2 = insert(root2, 7);` `root2 = insert(root2, 20);` `root2 = insert(root2, 4);` `root2 = insert(root2, 9);`   `printCommon(root1, root2);`   `// The code is contributed by Nidhi goel.`

Output

```Tree 1 :
0 1 4 5 7 9 10
Tree 2 :
4 7 9 10 20
Common Nodes:
4 7 9 10 ```

Time Complexity: O(M + N), Here ‘M’ and ‘N’ are the number of nodes in the first and second trees respectively.
Auxiliary Space: O(M + N), Need two separate arrays for storing inorder traversals of both the trees.

### (Linear Time and limited Extra Space) using iterative inorder traversal:

The idea is to use two stacks and store inorder traversal of trees in respective stacks but the maximum number of elements should be equal to that particular branch of the tree.

Follow the steps below to solve the problem:

• Create two stacks for two inorder traversals
• Push the Nodes of the first tree in stack s1, till that branch reaches NULL.
• Push the Nodes of the second tree in stack s2, till that branch reaches NULL
• If both branches reach NULL, then check
• If root1->data < root2->data,
• If node of the first tree is smaller than that of the second tree, then it is obvious that the inorder successors of the current node can have the same value as that of the second tree Node.
• Thus, we pop from s1.

Below is the implementation of the above approach.

## C++

 `// C++ program of iterative traversal based method to` `// find common elements in two BSTs.`   `#include ` `#include ` `using` `namespace` `std;`   `// A BST node` `struct` `Node {` `    ``int` `key;` `    ``struct` `Node *left, *right;` `};`   `// A utility function to create a new node` `Node* newNode(``int` `ele)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = ele;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// Function two print common elements in given two trees` `void` `printCommon(Node* root1, Node* root2)` `{` `    ``// Create two stacks for two inorder traversals` `    ``stack stack1, s1, s2;`   `    ``while` `(1) {` `        ``// Push the Nodes of first tree in stack s1` `        ``if` `(root1) {` `            ``s1.push(root1);` `            ``root1 = root1->left;` `        ``}`   `        ``// Push the Nodes of second tree in stack s2` `        ``else` `if` `(root2) {` `            ``s2.push(root2);` `            ``root2 = root2->left;` `        ``}`   `        ``// Both root1 and root2 are NULL here` `        ``else` `if` `(!s1.empty() && !s2.empty()) {` `            ``root1 = s1.top();` `            ``root2 = s2.top();`   `            ``// If current keys in two trees are same` `            ``if` `(root1->key == root2->key) {` `                ``cout << root1->key << ``" "``;` `                ``s1.pop();` `                ``s2.pop();`   `                ``// Move to the inorder successor` `                ``root1 = root1->right;` `                ``root2 = root2->right;` `            ``}`   `            ``else` `if` `(root1->key < root2->key) {` `                ``// If Node of first tree is smaller, than` `                ``// that of second tree, then its obvious` `                ``// that the inorder successors of current` `                ``// node can have same value as that of the` `                ``// second tree Node. Thus, we pop from s2` `                ``s1.pop();` `                ``root1 = root1->right;`   `                ``// root2 is set to NULL, because we need` `                ``// new Nodes of tree 1` `                ``root2 = NULL;` `            ``}` `            ``else` `if` `(root1->key > root2->key) {` `                ``s2.pop();` `                ``root2 = root2->right;` `                ``root1 = NULL;` `            ``}` `        ``}`   `        ``// Both roots and both stacks are empty` `        ``else` `            ``break``;` `    ``}` `}`   `// A utility function to do inorder traversal` `void` `inorder(``struct` `Node* root)` `{` `    ``if` `(root) {` `        ``inorder(root->left);` `        ``cout << root->key << ``" "``;` `        ``inorder(root->right);` `    ``}` `}`   `// A utility function to insert a new Node ` `// with given key in BST` `struct` `Node* insert(``struct` `Node* node, ``int` `key)` `{` `    ``// If the tree is empty, return a new Node` `    ``if` `(node == NULL)` `        ``return` `newNode(key);`   `    ``// Otherwise, recur down the tree` `    ``if` `(key < node->key)` `        ``node->left = insert(node->left, key);` `    ``else` `if` `(key > node->key)` `        ``node->right = insert(node->right, key);`   `    ``// Return the (unchanged) Node pointer` `    ``return` `node;` `}`   `// Driver program` `int` `main()` `{` `    ``// Create first tree as shown in example` `    ``Node* root1 = NULL;` `    ``root1 = insert(root1, 5);` `    ``root1 = insert(root1, 1);` `    ``root1 = insert(root1, 10);` `    ``root1 = insert(root1, 0);` `    ``root1 = insert(root1, 4);` `    ``root1 = insert(root1, 7);` `    ``root1 = insert(root1, 9);`   `    ``// Create second tree as shown in example` `    ``Node* root2 = NULL;` `    ``root2 = insert(root2, 10);` `    ``root2 = insert(root2, 7);` `    ``root2 = insert(root2, 20);` `    ``root2 = insert(root2, 4);` `    ``root2 = insert(root2, 9);`   `    ``cout << ``"Tree 1 : "` `<< endl;` `    ``inorder(root1);` `    ``cout << endl;`   `    ``cout << ``"Tree 2 : "` `<< endl;` `    ``inorder(root2);`   `    ``cout << ``"\nCommon Nodes: "` `<< endl;` `    ``printCommon(root1, root2);`   `    ``return` `0;` `}`

## Java

 `// Java program of iterative traversal based method to` `// find common elements in two BSTs.` `import` `java.util.*;` `class` `GfG {`   `    ``// A BST node` `    ``static` `class` `Node {` `        ``int` `key;` `        ``Node left, right;` `    ``}`   `    ``// A utility function to create a new node` `    ``static` `Node newNode(``int` `ele)` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.key = ele;` `        ``temp.left = ``null``;` `        ``temp.right = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// Function two print common elements in given two trees` `    ``static` `void` `printCommon(Node root1, Node root2)` `    ``{`   `        ``Stack s1 = ``new` `Stack();` `        ``Stack s2 = ``new` `Stack();`   `        ``while` `(``true``) {` `            ``// Push the Nodes of first tree in stack s1` `            ``if` `(root1 != ``null``) {` `                ``s1.push(root1);` `                ``root1 = root1.left;` `            ``}`   `            ``// Push the Nodes of second tree in stack s2` `            ``else` `if` `(root2 != ``null``) {` `                ``s2.push(root2);` `                ``root2 = root2.left;` `            ``}`   `            ``// Both root1 and root2 are NULL here` `            ``else` `if` `(!s1.isEmpty() && !s2.isEmpty()) {` `                ``root1 = s1.peek();` `                ``root2 = s2.peek();`   `                ``// If current keys in two trees are same` `                ``if` `(root1.key == root2.key) {` `                    ``System.out.print(root1.key + ``" "``);` `                    ``s1.pop();` `                    ``s2.pop();`   `                    ``// Move to the inorder successor` `                    ``root1 = root1.right;` `                    ``root2 = root2.right;` `                ``}`   `                ``else` `if` `(root1.key < root2.key) {` `                    ``// If Node of first tree is smaller,` `                    ``// than that of second tree, then its` `                    ``// obvious that the inorder successors` `                    ``// of current Node can have same value` `                    ``// as that of the second tree Node.` `                    ``// Thus, we pop from s2` `                    ``s1.pop();` `                    ``root1 = root1.right;`   `                    ``// root2 is set to NULL, because we need` `                    ``// new Nodes of tree 1` `                    ``root2 = ``null``;` `                ``}` `                ``else` `if` `(root1.key > root2.key) {` `                    ``s2.pop();` `                    ``root2 = root2.right;` `                    ``root1 = ``null``;` `                ``}` `            ``}`   `            ``// Both roots and both stacks are empty` `            ``else` `                ``break``;` `        ``}` `    ``}`   `    ``// A utility function to do inorder traversal` `    ``static` `void` `inorder(Node root)` `    ``{` `        ``if` `(root != ``null``) {` `            ``inorder(root.left);` `            ``System.out.print(root.key + ``" "``);` `            ``inorder(root.right);` `        ``}` `    ``}`   `    ``// A utility function to insert a new Node ` `    ``// with given key in BST` `    ``static` `Node insert(Node node, ``int` `key)` `    ``{` `        ``// If the tree is empty, return a new Node` `        ``if` `(node == ``null``)` `            ``return` `newNode(key);`   `        ``// Otherwise, recur down the tree` `        ``if` `(key < node.key)` `            ``node.left = insert(node.left, key);` `        ``else` `if` `(key > node.key)` `            ``node.right = insert(node.right, key);`   `        ``// Return the (unchanged) Node pointer` `        ``return` `node;` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Create first tree as shown in example` `        ``Node root1 = ``null``;` `        ``root1 = insert(root1, ``5``);` `        ``root1 = insert(root1, ``1``);` `        ``root1 = insert(root1, ``10``);` `        ``root1 = insert(root1, ``0``);` `        ``root1 = insert(root1, ``4``);` `        ``root1 = insert(root1, ``7``);` `        ``root1 = insert(root1, ``9``);`   `        ``// Create second tree as shown in example` `        ``Node root2 = ``null``;` `        ``root2 = insert(root2, ``10``);` `        ``root2 = insert(root2, ``7``);` `        ``root2 = insert(root2, ``20``);` `        ``root2 = insert(root2, ``4``);` `        ``root2 = insert(root2, ``9``);`   `        ``System.out.print(``"Tree 1 : "` `                         ``+ ``"\n"``);` `        ``inorder(root1);` `        ``System.out.println();` `        ``System.out.print(``"Tree 2 : "` `                         ``+ ``"\n"``);` `        ``inorder(root2);` `        ``System.out.println();` `        ``System.out.println(``"Common Nodes: "``);`   `        ``printCommon(root1, root2);` `    ``}` `}`

## Python3

 `# Python3 program of iterative traversal based` `# method to find common elements in two BSTs.`   `# A utility function to create a new node`     `class` `newNode:` `    ``def` `__init__(``self``, key):` `        ``self``.key ``=` `key` `        ``self``.left ``=` `self``.right ``=` `None`   `# Function two print common elements` `# in given two trees`     `def` `printCommon(root1, root2):`   `    ``# Create two stacks for two inorder` `    ``# traversals` `    ``s1 ``=` `[]` `    ``s2 ``=` `[]`   `    ``while` `1``:`   `        ``# append the Nodes of first` `        ``# tree in stack s1` `        ``if` `root1:` `            ``s1.append(root1)` `            ``root1 ``=` `root1.left`   `        ``# append the Nodes of second tree` `        ``# in stack s2` `        ``elif` `root2:` `            ``s2.append(root2)` `            ``root2 ``=` `root2.left`   `        ``# Both root1 and root2 are NULL here` `        ``elif` `len``(s1) !``=` `0` `and` `len``(s2) !``=` `0``:` `            ``root1 ``=` `s1[``-``1``]` `            ``root2 ``=` `s2[``-``1``]`   `            ``# If current keys in two trees are same` `            ``if` `root1.key ``=``=` `root2.key:` `                ``print``(root1.key, end``=``" "``)` `                ``s1.pop(``-``1``)` `                ``s2.pop(``-``1``)`   `                ``# move to the inorder successor` `                ``root1 ``=` `root1.right` `                ``root2 ``=` `root2.right`   `            ``elif` `root1.key < root2.key:`   `                ``# If Node of first tree is smaller, than` `                ``# that of second tree, then its obvious` `                ``# that the inorder successors of current` `                ``# Node can have same value as that of the` `                ``# second tree Node. Thus, we pop from s2` `                ``s1.pop(``-``1``)` `                ``root1 ``=` `root1.right`   `                ``# root2 is set to NULL, because we need` `                ``# new Nodes of tree 1` `                ``root2 ``=` `None` `            ``elif` `root1.key > root2.key:` `                ``s2.pop(``-``1``)` `                ``root2 ``=` `root2.right` `                ``root1 ``=` `None`   `        ``# Both roots and both stacks are empty` `        ``else``:` `            ``break`   `# A utility function to do inorder traversal`     `def` `inorder(root):` `    ``if` `root:` `        ``inorder(root.left)` `        ``print``(root.key, end``=``" "``)` `        ``inorder(root.right)`   `# A utility function to insert a new Node` `# with given key in BST`     `def` `insert(node, key):`   `    ``# If the tree is empty, return a new Node` `    ``if` `node ``=``=` `None``:` `        ``return` `newNode(key)`   `    ``# Otherwise, recur down the tree` `    ``if` `key < node.key:` `        ``node.left ``=` `insert(node.left, key)` `    ``elif` `key > node.key:` `        ``node.right ``=` `insert(node.right, key)`   `    ``# return the (unchanged) Node pointer` `    ``return` `node`     `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Create first tree as shown in example` `    ``root1 ``=` `None` `    ``root1 ``=` `insert(root1, ``5``)` `    ``root1 ``=` `insert(root1, ``1``)` `    ``root1 ``=` `insert(root1, ``10``)` `    ``root1 ``=` `insert(root1, ``0``)` `    ``root1 ``=` `insert(root1, ``4``)` `    ``root1 ``=` `insert(root1, ``7``)` `    ``root1 ``=` `insert(root1, ``9``)`   `    ``# Create second tree as shown in example` `    ``root2 ``=` `None` `    ``root2 ``=` `insert(root2, ``10``)` `    ``root2 ``=` `insert(root2, ``7``)` `    ``root2 ``=` `insert(root2, ``20``)` `    ``root2 ``=` `insert(root2, ``4``)` `    ``root2 ``=` `insert(root2, ``9``)`   `    ``print``(``"Tree 1 : "``)` `    ``inorder(root1)` `    ``print``()`   `    ``print``(``"Tree 2 : "``)` `    ``inorder(root2)` `    ``print``()`   `    ``print``(``"Common Nodes: "``)` `    ``printCommon(root1, root2)`   `# This code is contributed by PranchalK`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `// C# program of iterative traversal based method to` `// find common elements in two BSTs.` `public` `class` `GfG {`   `    ``// A BST node` `    ``public` `class` `Node {` `        ``public` `int` `key;` `        ``public` `Node left, right;` `    ``}`   `    ``// A utility function to create a new node` `    ``public` `static` `Node newNode(``int` `ele)` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.key = ele;` `        ``temp.left = ``null``;` `        ``temp.right = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// Function two print common elements in given two trees` `    ``public` `static` `void` `printCommon(Node root1, Node root2)` `    ``{` `        ``Stack s1 = ``new` `Stack();` `        ``Stack s2 = ``new` `Stack();`   `        ``while` `(``true``) {` `            ``// push the Nodes of first tree in stack s1` `            ``if` `(root1 != ``null``) {` `                ``s1.Push(root1);` `                ``root1 = root1.left;` `            ``}`   `            ``// push the Nodes of second tree in stack s2` `            ``else` `if` `(root2 != ``null``) {` `                ``s2.Push(root2);` `                ``root2 = root2.left;` `            ``}`   `            ``// Both root1 and root2 are NULL here` `            ``else` `if` `(s1.Count > 0 && s2.Count > 0) {` `                ``root1 = s1.Peek();` `                ``root2 = s2.Peek();`   `                ``// If current keys in two trees are same` `                ``if` `(root1.key == root2.key) {` `                    ``Console.Write(root1.key + ``" "``);` `                    ``s1.Pop();` `                    ``s2.Pop();`   `                    ``// move to the inorder successor` `                    ``root1 = root1.right;` `                    ``root2 = root2.right;` `                ``}`   `                ``else` `if` `(root1.key < root2.key) {` `                    ``// If Node of first tree is smaller,` `                    ``// than that of second tree, then its` `                    ``// obvious that the inorder successors` `                    ``// of current Node can have same value` `                    ``// as that of the second tree Node.` `                    ``// Thus, we pop from s2` `                    ``s1.Pop();` `                    ``root1 = root1.right;`   `                    ``// root2 is set to NULL, because we need` `                    ``// new Nodes of tree 1` `                    ``root2 = ``null``;` `                ``}` `                ``else` `if` `(root1.key > root2.key) {` `                    ``s2.Pop();` `                    ``root2 = root2.right;` `                    ``root1 = ``null``;` `                ``}` `            ``}`   `            ``// Both roots and both stacks are empty` `            ``else` `{` `                ``break``;` `            ``}` `        ``}` `    ``}`   `    ``// A utility function to do inorder traversal` `    ``public` `static` `void` `inorder(Node root)` `    ``{` `        ``if` `(root != ``null``) {` `            ``inorder(root.left);` `            ``Console.Write(root.key + ``" "``);` `            ``inorder(root.right);` `        ``}` `    ``}`   `    ``/* A utility function to insert a new Node with given` `     ``* key in BST */` `    ``public` `static` `Node insert(Node node, ``int` `key)` `    ``{` `        ``/* If the tree is empty, return a new Node */` `        ``if` `(node == ``null``) {` `            ``return` `newNode(key);` `        ``}`   `        ``/* Otherwise, recur down the tree */` `        ``if` `(key < node.key) {` `            ``node.left = insert(node.left, key);` `        ``}` `        ``else` `if` `(key > node.key) {` `            ``node.right = insert(node.right, key);` `        ``}`   `        ``/* return the (unchanged) Node pointer */` `        ``return` `node;` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``// Create first tree as shown in example` `        ``Node root1 = ``null``;` `        ``root1 = insert(root1, 5);` `        ``root1 = insert(root1, 1);` `        ``root1 = insert(root1, 10);` `        ``root1 = insert(root1, 0);` `        ``root1 = insert(root1, 4);` `        ``root1 = insert(root1, 7);` `        ``root1 = insert(root1, 9);`   `        ``// Create second tree as shown in example` `        ``Node root2 = ``null``;` `        ``root2 = insert(root2, 10);` `        ``root2 = insert(root2, 7);` `        ``root2 = insert(root2, 20);` `        ``root2 = insert(root2, 4);` `        ``root2 = insert(root2, 9);`   `        ``Console.Write(``"Tree 1 : "` `                      ``+ ``"\n"``);` `        ``inorder(root1);` `        ``Console.WriteLine();` `        ``Console.Write(``"Tree 2 : "` `                      ``+ ``"\n"``);` `        ``inorder(root2);` `        ``Console.WriteLine();` `        ``Console.Write(``"Common Nodes: "` `                      ``+ ``"\n"``);`   `        ``printCommon(root1, root2);` `    ``}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 `// Javascript equivalent of the python code` `// A utility function to create a new node ` `class Node {` `    ``constructor(key) {` `        ``this``.key = key;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `// Function two print common elements in given two trees ` `function` `printCommon(root1, root2) {` `    ``// Create two stacks for two inorder traversals` `    ``let s1 = [], s2 = [];`   `    ``while` `(``true``) {` `        ``// append the Nodes of first` `        ``// tree in stack s1` `        ``if` `(root1) {` `            ``s1.push(root1);` `            ``root1 = root1.left;` `        ``}` `        ``// append the Nodes of second tree` `        ``// in stack s2` `        ``else` `if` `(root2) {` `            ``s2.push(root2);` `            ``root2 = root2.left;` `        ``}` `        ``// Both root1 and root2 are NULL here` `        ``else` `if` `(s1.length !== 0 && s2.length !== 0) {` `            ``root1 = s1[s1.length - 1];` `            ``root2 = s2[s2.length - 1];`   `            ``// If current keys in two trees are same` `            ``if` `(root1.key === root2.key) {` `                ``console.log(root1.key);` `                ``s1.pop();` `                ``s2.pop();`   `                ``// move to the inorder successor` `                ``root1 = root1.right;` `                ``root2 = root2.right;` `            ``}` `            ``else` `if` `(root1.key < root2.key) {` `                ``// If Node of first tree is smaller, than` `                ``// that of second tree, then its obvious` `                ``// that the inorder successors of current` `                ``// Node can have same value as that of the` `                ``// second tree Node. Thus, we pop from s2` `                ``s1.pop();` `                ``root1 = root1.right;` `                ``// root2 is set to NULL, because we need` `                ``// new Nodes of tree 1` `                ``root2 = ``null``;` `            ``}` `            ``else` `if` `(root1.key > root2.key) {` `                ``s2.pop();` `                ``root2 = root2.right;` `                ``root1 = ``null``;` `            ``}` `        ``}` `        ``// Both roots and both stacks are empty` `        ``else` `{` `            ``break``;` `        ``}` `    ``}` `}`   `// A utility function to do inorder traversal ` `function` `inorder(root) {` `    ``if` `(root) {` `        ``inorder(root.left);` `        ``console.log(root.key);` `        ``inorder(root.right);` `    ``}` `}`   `// A utility function to insert a new Node ` `// with given key in BST ` `function` `insert(node, key) {` `    ``// If the tree is empty, return a new Node` `    ``if` `(node === ``null``) {` `        ``return` `new` `Node(key);` `    ``}` `    ``// Otherwise, recur down the tree` `    ``if` `(key < node.key) {` `        ``node.left = insert(node.left, key);` `    ``}` `    ``else` `if` `(key > node.key) {` `        ``node.right = insert(node.right, key);` `    ``}` `    ``// return the (unchanged) Node pointer` `    ``return` `node;` `}`   `// Driver Code ` `let root1 = ``null``;` `root1 = insert(root1, 5);` `root1 = insert(root1, 1);` `root1 = insert(root1, 10);` `root1 = insert(root1, 0);` `root1 = insert(root1, 4);` `root1 = insert(root1, 7);` `root1 = insert(root1, 9);`   `// Create second tree as shown in example ` `let root2 = ``null``;` `root2 = insert(root2, 10);` `root2 = insert(root2, 7);` `root2 = insert(root2, 20);` `root2 = insert(root2, 4);` `root2 = insert(root2, 9);`   `console.log(``"Tree 1 : "``);` `inorder(root1);` `console.log();`   `console.log(``"Tree 2 : "``);` `inorder(root2);` `console.log();`   `console.log(``"Common Nodes: "``);` `printCommon(root1, root2);`

Output

```Tree 1 :
0 1 4 5 7 9 10
Tree 2 :
4 7 9 10 20
Common Nodes:
4 7 9 10 ```

Time Complexity: O(N+M). Here ‘M’ and ‘N’ are the number of nodes in the first and second trees respectively
Auxiliary Space: O(h1 + h2), Where h1 and h2 are the heights of the first and second tree respectively.