Check if two BSTs contain same set of elements - GeeksforGeeks

01 Jul, 2021
Given two Binary Search Trees consisting of unique positive elements, we have to check whether the two BSTs contains same set or elements or not. Note: The structure of the two given BSTs can be different. For example,  
The above two BSTs contains same set of elements {5, 10, 12, 15, 20, 25} 
Method 1: The most simple method will be to traverse first tree and store its element in a list or array. Now, traverse 2nd tree and simultaneously check if the current element is present in the list or not. If yes, then mark the element in the list as negative and check for further elements otherwise if no, then immediately terminate the traversal and print No. If all the elements of 2nd tree is present in the list and are marked negative then finally traverse the list to check if there are any non-negative elements left. If Yes then it means that the first tree had some extra element otherwise the both tree consists same set of elements.Time Complexity: O( n * n ) , where n is the number of nodes in the BST. Auxiliary Space: O( n ).Method 2: This method is an optimization of above approach. If we observe carefully, we will see that in the above approach, search for element in the list takes linear time. We can optimize this operation to be done in constant time using a hashmap instead of list. We insert elements of both trees in different hash sets. Finally we compare if both hash sets contain same elements or not.Below is the complete implementation of above approach:  
C++
Java
Python3
C#
Javascript
// CPP program to check if two BSTs contains// same set of elements#include<bits/stdc++.h>using namespace std; // BST Nodestruct Node{    int data;    struct Node* left;    struct Node* right;}; // Utility function to create new NodeNode* newNode(int val){    Node* temp = new Node;    temp->data = val;    temp->left = temp->right = NULL;    return temp;} // function to insert elements of the// tree to map mvoid insertToHash(Node* root, unordered_set<int> &s){    if (!root)        return;    insertToHash(root->left, s);    s.insert(root->data);    insertToHash(root->right, s);} // function to check if the two BSTs contain// same set  of elementsbool checkBSTs(Node* root1, Node* root2){    // Base cases    if (!root1 && !root2)        return true;    if ((root1 && !root2) || (!root1 && root2))        return false;             // Create two hash sets and store    // elements both BSTs in them.    unordered_set<int> s1, s2;    insertToHash(root1, s1);    insertToHash(root2, s2);     // Return true if both hash sets    // contain same elements.    return (s1 == s2);} // Driver program to check above functionsint main(){    // First BST    Node* root1 = newNode(15);    root1->left = newNode(10);    root1->right = newNode(20);    root1->left->left = newNode(5);    root1->left->right = newNode(12);    root1->right->right = newNode(25);         // Second BST    Node* root2 = newNode(15);    root2->left = newNode(12);    root2->right = newNode(20);    root2->left->left = newNode(5);    root2->left->left->right = newNode(10);    root2->right->right = newNode(25);         // check if two BSTs have same set of elements    if (checkBSTs(root1, root2))        cout << "YES";    else        cout << "NO";    return 0;       }
// JAVA program to check if two BSTs contains// same set of elementsimport java.util.*; class GFG{ // BST Nodestatic class Node{    int data;    Node left;    Node right;}; // Utility function to create new Nodestatic Node newNode(int val){    Node temp = new Node();    temp.data = val;    temp.left = temp.right = null;    return temp;} // function to insert elements of the// tree to map mstatic void insertToHash(Node root, HashSet<Integer> s){    if (root == null)        return;    insertToHash(root.left, s);    s.add(root.data);    insertToHash(root.right, s);} // function to check if the two BSTs contain// same set of elementsstatic boolean checkBSTs(Node root1, Node root2){    // Base cases    if (root1 != null && root2 != null)        return true;    if ((root1 == null && root2 != null) || (root1 != null && root2 == null))        return false;             // Create two hash sets and store    // elements both BSTs in them.    HashSet<Integer> s1 = new HashSet<Integer>();    HashSet<Integer> s2 = new HashSet<Integer>();    insertToHash(root1, s1);    insertToHash(root2, s2);         // Return true if both hash sets    // contain same elements.    return (s1.equals(s2));} // Driver program to check above functionspublic static void main(String[] args){    // First BST    Node root1 = newNode(15);    root1.left = newNode(10);    root1.right = newNode(20);    root1.left.left = newNode(5);    root1.left.right = newNode(12);    root1.right.right = newNode(25);         // Second BST    Node root2 = newNode(15);    root2.left = newNode(12);    root2.right = newNode(20);    root2.left.left = newNode(5);    root2.left.left.right = newNode(10);    root2.right.right = newNode(25);         // check if two BSTs have same set of elements    if (checkBSTs(root1, root2))        System.out.print("YES");    else        System.out.print("NO");}    } // This code is contributed by 29AjayKumar
# Python3 program to check if two BSTs contains# same set of elements # BST Nodeclass Node:    def __init__(self):        self.val = 0        self.left = None        self.right = None # Utility function to create Nodedef Node_(val1):     temp = Node()    temp.val = val1    temp.left = temp.right = None    return temp s = {} # function to insert elements of the# tree to map mdef insertToHash(root):     if (root == None):        return    insertToHash(root.left)    s.add(root.data)    insertToHash(root.right) # function to check if the two BSTs contain# same set of elementsdef checkBSTs(root1, root2):     # Base cases    if (root1 != None and root2 != None) :        return True    if ((root1 == None and root2 != None) or        (root1 != None and root2 == None)):        return False             # Create two hash sets and store    # elements both BSTs in them.    s1 = {}    s2 = {}    s = s1    insertToHash(root1)    s1 = s    s = s2    insertToHash(root2)    s2 = s         # Return True if both hash sets    # contain same elements.    return (s1 == (s2)) # Driver code # First BSTroot1 = Node_(15)root1.left = Node_(10)root1.right = Node_(20)root1.left.left = Node_(5)root1.left.right = Node_(12)root1.right.right = Node_(25)     # Second BSTroot2 = Node_(15)root2.left = Node_(12)root2.right = Node_(20)root2.left.left = Node_(5)root2.left.left.right = Node_(10)root2.right.right = Node_(25)     # check if two BSTs have same set of elementsif (checkBSTs(root1, root2)):    print("YES")else:    print("NO")     # This code is contributed by Arnab Kundu
// C# program to check if two BSTs contains// same set of elementsusing System;using System.Collections.Generic; class GFG{ // BST Nodeclass Node{    public int data;    public Node left;    public Node right;}; // Utility function to create new Nodestatic Node newNode(int val){    Node temp = new Node();    temp.data = val;    temp.left = temp.right = null;    return temp;} // function to insert elements of the// tree to map mstatic void insertToHash(Node root,                         HashSet<int> s){    if (root == null)        return;    insertToHash(root.left, s);    s.Add(root.data);    insertToHash(root.right, s);} // function to check if the two BSTs contain// same set of elementsstatic bool checkBSTs(Node root1, Node root2){    // Base cases    if (root1 != null && root2 != null)        return true;    if ((root1 == null && root2 != null) ||        (root1 != null && root2 == null))        return false;             // Create two hash sets and store    // elements both BSTs in them.    HashSet<int> s1 = new HashSet<int>();    HashSet<int> s2 = new HashSet<int>();    insertToHash(root1, s1);    insertToHash(root2, s2);         // Return true if both hash sets    // contain same elements.    return (s1.Equals(s2));} // Driver Codepublic static void Main(String[] args){    // First BST    Node root1 = newNode(15);    root1.left = newNode(10);    root1.right = newNode(20);    root1.left.left = newNode(5);    root1.left.right = newNode(12);    root1.right.right = newNode(25);         // Second BST    Node root2 = newNode(15);    root2.left = newNode(12);    root2.right = newNode(20);    root2.left.left = newNode(5);    root2.left.left.right = newNode(10);    root2.right.right = newNode(25);         // check if two BSTs have same set of elements    if (checkBSTs(root1, root2))        Console.Write("YES");    else        Console.Write("NO");}    } // This code is contributed by PrinciRaj1992
<script> // JavaScript program to check if two BSTs contains// same set of elements // BST Nodeclass Node{    constructor()    {        this.data = 0;        this.left = null;        this.right = null;    }}; // Utility function to create new Nodefunction newNode(val){    var temp = new Node();    temp.data = val;    temp.left = temp.right = null;    return temp;} // function to insert elements of the// tree to map mfunction insertToHash(root, s){    if (root == null)        return;    insertToHash(root.left, s);    s.add(root.data);    insertToHash(root.right, s);} // function to check if the two BSTs contain// same set of elementsfunction checkBSTs(root1, root2){    // Base cases    if (root1 != null && root2 != null)        return true;    if ((root1 == null && root2 != null) ||        (root1 != null && root2 == null))        return false;             // Create two hash sets and store    // elements both BSTs in them.    var s1 = new Set();    var s2 = new Set();    insertToHash(root1, s1);    insertToHash(root2, s2);         // Return true if both hash sets    // contain same elements.    return (s1==s2);} // Driver Code// First BSTvar root1 = newNode(15);root1.left = newNode(10);root1.right = newNode(20);root1.left.left = newNode(5);root1.left.right = newNode(12);root1.right.right = newNode(25); // Second BSTvar root2 = newNode(15);root2.left = newNode(12);root2.right = newNode(20);root2.left.left = newNode(5);root2.left.left.right = newNode(10);root2.right.right = newNode(25); // check if two BSTs have same set of elementsif (checkBSTs(root1, root2))    document.write("YES");else    document.write("NO"); </script>
Output:  
YES
Time Complexity: O( n ), where n is the number of nodes in the trees. Auxiliary Space: O( n ).Method 3: We know about an interesting property of BST that inorder traversal of a BST generates a sorted array. So we can do inorder traversals of both the BSTs and generate two arrays and finally we can compare these two arrays. If both of the arrays are same then the BSTs have same set of elements otherwise not. 
C++
Java
Python3
C#
Javascript
// CPP program to check if two BSTs contains// same set of elements#include<bits/stdc++.h>using namespace std; // BST Nodestruct Node{    int data;    struct Node* left;    struct Node* right;}; // Utility function to create new NodeNode* newNode(int val){    Node* temp = new Node;    temp->data = val;    temp->left = temp->right = NULL;    return temp;} // function to insert elements of the// tree to map mvoid storeInorder(Node* root, vector<int> &v){    if (!root)        return;    storeInorder(root->left, v);    v.push_back(root->data);    storeInorder(root->right, v);} // function to check if the two BSTs contain// same set  of elementsbool checkBSTs(Node* root1, Node* root2){    // Base cases    if (!root1 && !root2)        return true;    if ((root1 && !root2) || (!root1 && root2))        return false;             // Create two vectors and store    // inorder traversals of both BSTs    // in them.    vector<int> v1, v2;    storeInorder(root1, v1);    storeInorder(root2, v2);     // Return true if both vectors are    // identical    return (v1 == v2);} // Driver program to check above functionsint main(){    // First BST    Node* root1 = newNode(15);    root1->left = newNode(10);    root1->right = newNode(20);    root1->left->left = newNode(5);    root1->left->right = newNode(12);    root1->right->right = newNode(25);         // Second BST    Node* root2 = newNode(15);    root2->left = newNode(12);    root2->right = newNode(20);    root2->left->left = newNode(5);    root2->left->left->right = newNode(10);    root2->right->right = newNode(25);         // check if two BSTs have same set of elements    if (checkBSTs(root1, root2))        cout << "YES";    else        cout << "NO";    return 0;       }
// Java program to check if two BSTs// contain same set of elementsimport java.util.*; class GFG{ // BST Nodestatic class Node{    int data;    Node left;    Node right;}; // Utility function to create new Nodestatic Node newNode(int val){    Node temp = new Node();    temp.data = val;    temp.left = temp.right = null;    return temp;} // function to insert elements // of the tree to map mstatic void storeInorder(Node root,                         Vector<Integer> v){    if (root == null)        return;    storeInorder(root.left, v);    v.add(root.data);    storeInorder(root.right, v);} // function to check if the two BSTs// contain same set of elementsstatic boolean checkBSTs(Node root1, Node root2){    // Base cases    if (root1 != null && root2 != null)        return true;    if ((root1 == null && root2 != null) ||        (root1 != null && root2 == null))        return false;             // Create two vectors and store    // inorder traversals of both BSTs    // in them.    Vector<Integer> v1 = new Vector<Integer>();    Vector<Integer> v2 = new Vector<Integer>();    storeInorder(root1, v1);    storeInorder(root2, v2);     // Return true if both vectors are    // identical    return (v1 == v2);} // Driver Codepublic static void main(String[] args){    // First BST    Node root1 = newNode(15);    root1.left = newNode(10);    root1.right = newNode(20);    root1.left.left = newNode(5);    root1.left.right = newNode(12);    root1.right.right = newNode(25);         // Second BST    Node root2 = newNode(15);    root2.left = newNode(12);    root2.right = newNode(20);    root2.left.left = newNode(5);    root2.left.left.right = newNode(10);    root2.right.right = newNode(25);         // check if two BSTs have same set of elements    if (checkBSTs(root1, root2))        System.out.print("YES");    else        System.out.print("NO");}    } // This code is contributed by Rajput-Ji
# Python3 program to check if two BSTs contains# same set of elements # BST Nodeclass Node:    def __init__(self):        self.val = 0        self.left = None        self.right = None # Utility function to create Nodedef Node_(val1):     temp = Node()    temp.val = val1    temp.left = temp.right = None    return temp v = [] # function to insert elements of the# tree to map mdef storeInorder(root):     if (root == None):        return    storeInorder(root.left)    v.append(root.data)    storeInorder(root.right) # function to check if the two BSTs contain# same set of elementsdef checkBSTs(root1, root2):     # Base cases    if (root1 != None and root2 != None) :        return True    if ((root1 == None and root2 != None) or \        (root1 != None and root2 == None)):        return False             # Create two hash sets and store    # elements both BSTs in them.    v1 = []    v2 = []    v = v1    storeInorder(root1)    v1 = v    v = v2    storeInorder(root2)    v2 = v         # Return True if both hash sets    # contain same elements.    return (v1 == v2) # Driver code # First BSTroot1 = Node_(15)root1.left = Node_(10)root1.right = Node_(20)root1.left.left = Node_(5)root1.left.right = Node_(12)root1.right.right = Node_(25)     # Second BSTroot2 = Node_(15)root2.left = Node_(12)root2.right = Node_(20)root2.left.left = Node_(5)root2.left.left.right = Node_(10)root2.right.right = Node_(25)     # check if two BSTs have same set of elementsif (checkBSTs(root1, root2)):    print("YES")else:    print("NO")     # This code is contributed by SHUBHAMSINGH10
// C# program to check if two BSTs// contain same set of elementsusing System;using System.Collections.Generic; class GFG{ // BST Nodeclass Node{    public int data;    public Node left;    public Node right;}; // Utility function to create new Nodestatic Node newNode(int val){    Node temp = new Node();    temp.data = val;    temp.left = temp.right = null;    return temp;} // function to insert elements// of the tree to map mstatic void storeInorder(Node root,                         List<int> v){    if (root == null)        return;    storeInorder(root.left, v);    v.Add(root.data);    storeInorder(root.right, v);} // function to check if the two BSTs// contain same set of elementsstatic bool checkBSTs(Node root1,                      Node root2){    // Base cases    if (root1 != null && root2 != null)        return true;    if ((root1 == null && root2 != null) ||        (root1 != null && root2 == null))        return false;             // Create two vectors and store    // inorder traversals of both BSTs    // in them.    List<int> v1 = new List<int>();    List<int> v2 = new List<int>();    storeInorder(root1, v1);    storeInorder(root2, v2);     // Return true if both vectors are    // identical    return (v1 == v2);} // Driver Codepublic static void Main(String[] args){    // First BST    Node root1 = newNode(15);    root1.left = newNode(10);    root1.right = newNode(20);    root1.left.left = newNode(5);    root1.left.right = newNode(12);    root1.right.right = newNode(25);         // Second BST    Node root2 = newNode(15);    root2.left = newNode(12);    root2.right = newNode(20);    root2.left.left = newNode(5);    root2.left.left.right = newNode(10);    root2.right.right = newNode(25);         // check if two BSTs have    // same set of elements    if (checkBSTs(root1, root2))        Console.Write("YES");    else        Console.Write("NO");}    } // This code is contributed by Rajput-Ji
<script> // JavaScript program to check if two BSTs// contain same set of elements     // BST Nodeclass Node {    constructor() {        this.data = 0;        this.prev = null;        this.next = null;    }}     // Utility function to create new Node    function newNode(val)    {        var temp = new Node();        temp.data = val;        temp.left = temp.right = null;        return temp;    }     // function to insert elements    // of the tree to map m    function storeInorder(root, v) {        if (root == null)            return;        storeInorder(root.left, v);        v.push(root.data);        storeInorder(root.right, v);    }     // function to check if the two BSTs    // contain same set of elements    function checkBSTs(root1,  root2)    {        // Base cases        if (root1 != null && root2 != null)            return true;        if ((root1 == null && root2 != null) ||            (root1 != null && root2 == null))            return false;         // Create two vectors and store        // inorder traversals of both BSTs        // in them.        var v1 = [];        var v2 = [];        storeInorder(root1, v1);        storeInorder(root2, v2);         // Return true if both vectors are        // identical        return (v1 == v2);    }     // Driver Code             // First BST        var root1 = newNode(15);        root1.left = newNode(10);        root1.right = newNode(20);        root1.left.left = newNode(5);        root1.left.right = newNode(12);        root1.right.right = newNode(25);         // Second BST        var root2 = newNode(15);        root2.left = newNode(12);        root2.right = newNode(20);        root2.left.left = newNode(5);        root2.left.left.right = newNode(10);        root2.right.right = newNode(25);         // check if two BSTs have same set of elements        if (checkBSTs(root1, root2))            document.write("YES");        else            document.write("NO"); // This code is contributed by Rajput-Ji </script>
Output:  
YES
Time Complexity: O( n ). Auxiliary Space: O( n ). 
YouTubeGeeksforGeeks502K subscribersCheck if two BSTs contain same set of elements | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 4:34•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=c-OSdbpOVDE" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
This article is contributed by Harsh Agarwal. 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.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
 
29AjayKumar
princiraj1992
Rajput-Ji
andrew1234
SHUBHAMSINGH10
rutvik_56
cpp-unordered_set
cpp-vector
Binary Search Tree
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Advantages of BST over Hash Table
Difference between Binary Tree and Binary Search Tree
Inorder predecessor and successor for a given key in BST
Sorted Linked List to Balanced BST
Print BST keys in the given range
Binary Tree to Binary Search Tree Conversion
Insert a node in Binary Search Tree Iteratively
C Program for Red Black Tree Insertion
Find the node with maximum value in a Binary Search Tree
Total number of possible Binary Search Trees and Binary Trees with n keys