Binary Tree to Binary Search Tree Conversion using STL set - GeeksforGeeks

24 Jun, 2021
Given a Binary Tree, convert it to a Binary Search Tree. The conversion must be done in such a way that keeps the original structure of the Binary Tree.This solution will use Sets of C++ STL instead of array-based solution.Examples: 
Example 1
Input:
          10
         /  \
        2    7
       / \
      8   4
Output:
          8
         /  \
        4    10
       / \
      2   7


Example 2
Input:
          10
         /  \
        30   15
       /      \
      20       5
Output:
          15
         /  \
       10    20
       /      \
      5        30
Solution 
Copy the items of binary tree in a set while doing inorder traversal. This takes O(n log n) time. Note that set in C++ STL is implemented using a Self Balancing Binary Search Tree like Red Black Tree, AVL Tree, etcThere is no need to sort the set as sets in C++ are implemented using Self-balancing binary search trees due to which each operation such as insertion, searching, deletion, etc takes O(log n) time.Now simply copy the items of set one by one from beginning to the tree while doing inorder traversal of the tree. Care should be taken as when copying each item of set from its beginning, we first copy it to the tree while doing inorder traversal, then remove it from the set as well.
Copy the items of binary tree in a set while doing inorder traversal. This takes O(n log n) time. Note that set in C++ STL is implemented using a Self Balancing Binary Search Tree like Red Black Tree, AVL Tree, etc
There is no need to sort the set as sets in C++ are implemented using Self-balancing binary search trees due to which each operation such as insertion, searching, deletion, etc takes O(log n) time.
Now simply copy the items of set one by one from beginning to the tree while doing inorder traversal of the tree. Care should be taken as when copying each item of set from its beginning, we first copy it to the tree while doing inorder traversal, then remove it from the set as well.
Now the above solution is simpler and easier to implement than the array-based conversion of Binary tree to Binary search tree explained here- Conversion of Binary Tree to Binary Search tree (Set-1), where we had to separately make a function to sort the items of the array after copying the items from tree to it.Program to convert a binary tree to a binary search tree using the set. 
C++
Java
Python3
C#
Javascript
/* CPP program to convert a Binary tree to BST   using sets as containers. */#include <bits/stdc++.h>using namespace std; struct Node {    int data;    struct Node *left, *right;}; // function to store the nodes in set while// doing inorder traversal.void storeinorderInSet(Node* root, set<int>& s){    if (!root)        return;     // visit the left subtree first    storeinorderInSet(root->left, s);     // insertion takes order of O(logn) for sets    s.insert(root->data);     // visit the right subtree    storeinorderInSet(root->right, s); } // Time complexity  = O(nlogn) // function to copy items of set one by one// to the tree while doing inorder traversalvoid setToBST(set<int>& s, Node* root){    // base condition    if (!root)        return;     // first move to the left subtree and    // update items    setToBST(s, root->left);     // iterator initially pointing to the    // beginning of set    auto it = s.begin();     // copying the item at beginning of    // set(sorted) to the tree.    root->data = *it;     // now erasing the beginning item from set.    s.erase(it);     // now move to right subtree and update items    setToBST(s, root->right); } // T(n) = O(nlogn) time // Converts Binary tree to BST.void binaryTreeToBST(Node* root){    set<int> s;     // populating the set with the tree's    // inorder traversal data    storeinorderInSet(root, s);     // now sets are by default sorted as    // they are implemented using self-    // balancing BST     // copying items from set to the tree    // while inorder traversal which makes a BST    setToBST(s, root); } // Time complexity  =  O(nlogn),  // Auxiliary Space = O(n) for set. // helper function to create a nodeNode* newNode(int data){    // dynamically allocating memory    Node* temp = new Node();    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // function to do inorder traversalvoid inorder(Node* root){    if (!root)        return;    inorder(root->left);    cout << root->data << " ";    inorder(root->right);} int main(){    Node* root = newNode(5);    root->left = newNode(7);    root->right = newNode(9);    root->right->left = newNode(10);    root->left->left = newNode(1);    root->left->right = newNode(6);    root->right->right = newNode(11);     /* Constructing tree given in the above figure           5         /   \        7     9       /\    / \      1  6   10 11   */     // converting the above Binary tree to BST    binaryTreeToBST(root);    cout << "Inorder traversal of BST is: " << endl;    inorder(root);    return 0;}
/* Java program to convert a Binary tree to BSTusing sets as containers. */import java.util.*; class Solution{static class Node{    int data;    Node left, right;} // setstatic Set<Integer> s = new HashSet<Integer>(); // function to store the nodes in set while// doing inorder traversal.static void storeinorderInSet(Node root){    if (root == null)        return;     // visit the left subtree first    storeinorderInSet(root.left);     // insertion takes order of O(logn) for sets    s.add(root.data);     // visit the right subtree    storeinorderInSet(root.right); } // Time complexity = O(nlogn) // function to copy items of set one by one// to the tree while doing inorder traversalstatic void setToBST( Node root){    // base condition    if (root == null)        return;     // first move to the left subtree and    // update items    setToBST( root.left);     // iterator initially pointing to the    // beginning of set    // copying the item at beginning of    // set(sorted) to the tree.    root.data = s.iterator().next();     // now erasing the beginning item from set.    s.remove(root.data);     // now move to right subtree and update items    setToBST( root.right); } // T(n) = O(nlogn) time // Converts Binary tree to BST.static void binaryTreeToBST(Node root){    s.clear();     // populating the set with the tree's    // inorder traversal data    storeinorderInSet(root);     // now sets are by default sorted as    // they are implemented using self-    // balancing BST     // copying items from set to the tree    // while inorder traversal which makes a BST    setToBST( root); } // Time complexity = O(nlogn),// Auxiliary Space = O(n) for set. // helper function to create a nodestatic Node newNode(int data){    // dynamically allocating memory    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // function to do inorder traversalstatic void inorder(Node root){    if (root == null)        return;    inorder(root.left);    System.out.print(root.data + " ");    inorder(root.right);} // Driver codepublic static void main(String args[]){    Node root = newNode(5);    root.left = newNode(7);    root.right = newNode(9);    root.right.left = newNode(10);    root.left.left = newNode(1);    root.left.right = newNode(6);    root.right.right = newNode(11);     /* Constructing tree given in the above figure        5        / \        7     9    /\ / \    1 6 10 11 */     // converting the above Binary tree to BST    binaryTreeToBST(root);    System.out.println( "Inorder traversal of BST is: " );    inorder(root);}} // This code is contributed by Arnab Kundu
# Python3 program to convert a Binary tree# to BST using sets as containers. # Binary Tree Node""" A utility function to create anew BST node """class newNode:     # Construct to create a newNode    def __init__(self, data):        self.data = data        self.left = None        self.right = None # function to store the nodes in set# while doing inorder traversal.def storeinorderInSet(root, s):     if (not root) :        return     # visit the left subtree first    storeinorderInSet(root.left, s)     # insertion takes order of O(logn)    # for sets    s.add(root.data)     # visit the right subtree    storeinorderInSet(root.right, s) # Time complexity = O(nlogn) # function to copy items of set one by one# to the tree while doing inorder traversaldef setToBST(s, root) :     # base condition    if (not root):        return     # first move to the left subtree and    # update items    setToBST(s, root.left)     # iterator initially pointing to    # the beginning of set    it = next(iter(s))     # copying the item at beginning of    # set(sorted) to the tree.    root.data = it     # now erasing the beginning item from set.    s.remove(it)     # now move to right subtree    # and update items    setToBST(s, root.right) # T(n) = O(nlogn) time # Converts Binary tree to BST.def binaryTreeToBST(root):     s = set()     # populating the set with the tree's    # inorder traversal data    storeinorderInSet(root, s)     # now sets are by default sorted as    # they are implemented using self-    # balancing BST     # copying items from set to the tree    # while inorder traversal which makes a BST    setToBST(s, root) # Time complexity = O(nlogn),# Auxiliary Space = O(n) for set. # function to do inorder traversaldef inorder(root) :     if (not root) :        return    inorder(root.left)    print(root.data, end = " ")    inorder(root.right) # Driver Codeif __name__ == '__main__':     root = newNode(5)    root.left = newNode(7)    root.right = newNode(9)    root.right.left = newNode(10)    root.left.left = newNode(1)    root.left.right = newNode(6)    root.right.right = newNode(11)     """ Constructing tree given in        the above figure        5        / \        7     9    /\ / \    1 6 10 11 """     # converting the above Binary tree to BST    binaryTreeToBST(root)    print("Inorder traversal of BST is: ")    inorder(root) # This code is contributed by# Shubham Singh(SHUBHAMSINGH10)
// C# program to convert// a Binary tree to BSTusing System;using System.Collections;using System.Collections.Generic;using System.Linq;class Solution{     class Node{  public int data;  public Node left,              right;}  // setstatic SortedSet<int> s =       new SortedSet<int>();  // function to store the nodes// in set while doing inorder// traversal.static void storeinorderInSet(Node root){  if (root == null)    return;   // visit the left subtree  // first  storeinorderInSet(root.left);   // insertion takes order of  // O(logn) for sets  s.Add(root.data);   // visit the right subtree  storeinorderInSet(root.right); }   // Time complexity = O(nlogn)  // function to copy items of// set one by one to the tree// while doing inorder traversalstatic void setToBST(Node root){  // base condition  if (root == null)    return;   // first move to the left  // subtree and update items  setToBST(root.left);   // iterator initially pointing  // to the beginning of set copying  // the item at beginning of set(sorted)  // to the tree.  root.data = s.First();   // now erasing the beginning item  // from set.  s.Remove(s.First());   // now move to right subtree and  // update items  setToBST( root.right);}   // T(n) = O(nlogn) time // Converts Binary tree to BST.static void binaryTreeToBST(Node root){  s.Clear();   // populating the set with  // the tree's inorder traversal  // data  storeinorderInSet(root);   // now sets are by default sorted  // as they are implemented using  // self-balancing BST   // copying items from set to the  // tree while inorder traversal  // which makes a BST  setToBST( root);  }   // Time complexity = O(nlogn),// Auxiliary Space = O(n) for set.  // helper function to create a nodestatic Node newNode(int data){  // dynamically allocating  // memory  Node temp = new Node();  temp.data = data;  temp.left = temp.right = null;  return temp;}  // function to do inorder traversalstatic void inorder(Node root){  if (root == null)    return;  inorder(root.left);  Console.Write(root.data + " ");  inorder(root.right);}  // Driver codepublic static void Main(string []args){  Node root = newNode(5);  root.left = newNode(7);  root.right = newNode(9);  root.right.left = newNode(10);  root.left.left = newNode(1);  root.left.right = newNode(6);  root.right.right = newNode(11);   /* Constructing tree given in  // the above figure        5        / \        7     9    /\ / \    1 6 10 11 */   // converting the above Binary  // tree to BST  binaryTreeToBST(root);  Console.Write("Inorder traversal of " +                "BST is: \n" );  inorder(root);}} // This code is contributed by Rutvik_56
<script> // JavaScript program to convert// a Binary tree to BST class Node{  constructor()  {    this.data = 0;    this.right = null;    this.left = null;  }}  // setvar s = new Set();  // function to store the nodes// in set while doing inorder// traversal.function storeinorderInSet(root){  if (root == null)    return;   // visit the left subtree  // first  storeinorderInSet(root.left);   // insertion takes order of  // O(logn) for sets  s.add(root.data);   // visit the right subtree  storeinorderInSet(root.right); }   // Time complexity = O(nlogn)  // function to copy items of// set one by one to the tree// while doing inorder traversalfunction setToBST(root){  // base condition  if (root == null)    return;   // first move to the left  // subtree and update items  setToBST(root.left);   var tmp = [...s].sort((a,b)=> a-b);  // iterator initially pointing  // to the beginning of set copying  // the item at beginning of set(sorted)  // to the tree.  root.data = tmp[0];   // now erasing the beginning item  // from set.  s.delete(tmp[0]);   // now move to right subtree and  // update items  setToBST( root.right);}   // T(n) = O(nlogn) time // Converts Binary tree to BST.function binaryTreeToBST(root){  s = new Set();   // populating the set with  // the tree's inorder traversal  // data  storeinorderInSet(root);   // now sets are by default sorted  // as they are implemented using  // self-balancing BST   // copying items from set to the  // tree while inorder traversal  // which makes a BST  setToBST( root);  }   // Time complexity = O(nlogn),// Auxiliary Space = O(n) for set.  // helper function to create a nodefunction newNode(data){  // dynamically allocating  // memory  var temp = new Node();  temp.data = data;  temp.left = temp.right = null;  return temp;}  // function to do inorder traversalfunction inorder(root){  if (root == null)    return;  inorder(root.left);  document.write(root.data + " ");  inorder(root.right);}  // Driver codevar root = newNode(5);root.left = newNode(7);root.right = newNode(9);root.right.left = newNode(10);root.left.left = newNode(1);root.left.right = newNode(6);root.right.right = newNode(11);/* Constructing tree given in// the above figure      5      / \      7     9  /\ / \  1 6 10 11 */// converting the above Binary// tree to BSTbinaryTreeToBST(root);document.write("Inorder traversal of " +              "BST is: <br>" );inorder(root); </script>
Inorder traversal of BST is: 
1 5 6 7 9 10 11
 
Time Complexity: O(n Log n) Auxiliary Space: (n) 
SHUBHAMSINGH10
andrew1234
rutvik_56
itsok
cpp-set
Binary Search Tree
Tree
Binary Search Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Red-Black Tree | Set 2 (Insert)
Inorder Successor in Binary Search Tree
Find the node with minimum value in a Binary Search Tree
Optimal Binary Search Tree | DP-24
Advantages of BST over Hash Table
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
Inorder Tree Traversal without Recursion
Binary Tree | Set 3 (Types of Binary Tree)