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
\
9root2: 10
/ \
7 20
/ \
4 9
Output: 4 7 9 10
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 <iostream> #include <stack> #include <vector> 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<Integer> 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<Integer> inorder1 = new ArrayList<Integer>(); ArrayList<Integer> inorder2 = new ArrayList<Integer>(); // 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(); } } |
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.
- If root1->data < root2->data,
Below is the implementation of the above approach.
C++
// C++ program of iterative traversal based method to // find common elements in two BSTs. #include <iostream> #include <stack> 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<Node*> 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<Node> s1 = new Stack<Node>(); Stack<Node> s2 = new Stack<Node>(); 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<Node> s1 = new Stack<Node>(); Stack<Node> s2 = new Stack<Node>(); 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 |
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.
This article is contributed by Ekta Goel. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Please Login to comment...