给定二叉树，将其转换为二叉搜索树。转换必须以保留二叉树原始结构的方式进行。
此解决方案将使用C++ STL集而不是基于数组的解决方案。
例子：
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
解决方案
- 在进行有序遍历时，将二进制树中的项目复制到一组中。这需要O(n log n)时间。请注意，C++ STL中的设置是使用自平衡二进制搜索树(如红黑树，AVL树等)实现的
- 有没有必要进行排序集合作为集合在C++中使用的是自平衡二叉搜索树，由于其每个操作如插入，检索，删除等需要O(log n)的时间来实现。
- 现在，只需按顺序从树的开始处逐个复制set的项目，同时进行树的有序遍历即可。应注意从它开始复制集的每一个项目的时候，我们首先把它复制到树边做序遍历，然后从集中删除它。
现在，上述解决方案比此处解释的将基于数组的二叉树到二叉搜索树的转换更简单，更容易实现-将二叉树转换为二叉搜索树(Set-1)，在此必须分别创建一个函数进行排序将树中的项目复制到数组后，将数组中的项目复制到数组中。
程序使用该集将二叉树转换为二叉树。
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& 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& 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 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 s =
new SortedSet();
// 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 输出：
Inorder traversal of BST is:
1 5 6 7 9 10 11
时间复杂度： O(n Log n)
辅助空间： (n)