# Binary Tree to Binary Search Tree Conversion using STL set

• Difficulty Level : Easy
• Last Updated : 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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

1. 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
2. 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.
3. 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++

 `/* CPP program to convert a Binary tree to BST``   ``using sets as containers. */``#include ``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 traversal``void` `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 node``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 traversal``void` `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

 `/* Java program to convert a Binary tree to BST``using sets as containers. */``import` `java.util.*;` `class` `Solution``{``static` `class` `Node``{``    ``int` `data;``    ``Node left, right;``}` `// set``static` `Set s = ``new` `HashSet();` `// 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 traversal``static` `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 node``static` `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 traversal``static` `void` `inorder(Node root)``{``    ``if` `(root == ``null``)``        ``return``;``    ``inorder(root.left);``    ``System.out.print(root.data + ``" "``);``    ``inorder(root.right);``}` `// Driver code``public` `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

 `# Python3 program to convert a Binary tree``# to BST using sets as containers.` `# Binary Tree Node``""" A utility function to create a``new 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 traversal``def` `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 traversal``def` `inorder(root) :` `    ``if` `(``not` `root) :``        ``return``    ``inorder(root.left)``    ``print``(root.data, end ``=` `" "``)``    ``inorder(root.right)` `# Driver Code``if` `__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#

 `// C# program to convert``// a Binary tree to BST``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;``using` `System.Linq;``class` `Solution{``    ` `class` `Node``{``  ``public` `int` `data;``  ``public` `Node left,``              ``right;``}`` ` `// set``static` `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 traversal``static` `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 node``static` `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 traversal``static` `void` `inorder(Node root)``{``  ``if` `(root == ``null``)``    ``return``;``  ``inorder(root.left);``  ``Console.Write(root.data + ``" "``);``  ``inorder(root.right);``}`` ` `// Driver code``public` `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`

## Javascript

 ``
Output:
```Inorder traversal of BST is:
1 5 6 7 9 10 11```

Time Complexity: O(n Log n)
Auxiliary Space: (n)

My Personal Notes arrow_drop_up