在 C++ STL 中使用向量创建平衡 BST

给定一个未排序的向量arr ，任务是使用数组的元素创建一个平衡的二叉搜索树。

注意：可以有不止一个平衡的 BST。形成任何是可以接受的

例子：

Input: arr[] = { 2, 1, 3}
Output: 2 1 3
Explanation: The tree formed is show below. The preorder traversal is 2 1 3
     2
   /  \
 1    3  

Input: arr[] = {4, 3, 1, 2}
Output: 2 1 3 4
Explanation: The tree formed is
        2
      /  \
    1    3
           \
            4
Another possible option can provide preorder traversal is 3 2 1 4

方法：要解决此问题，请按照以下步骤操作：

1. 首先，我们将使用 sort函数对向量进行排序。
2. 现在，获取向量的中间并使其成为根。
3. 递归地对左半边和右半边做同样的事情。
   1. 获取左半部分的中间，使其成为步骤 2 中创建的根的左子节点。
   2. 获取右半部分的中间，使其成为步骤 2 中创建的根的右子节点。

下面是上述方法的实现：

C++

// C++ program to print BST in given range
#include 
using namespace std;
  
// Node of Binary Search Tree
class Node {
public:
    Node* left;
    int data;
    Node* right;
  
    Node(int d)
    {
        data = d;
        left = right = NULL;
    }
};
  
// A function that constructs Balanced
// Binary Search Tree from a vector
Node* createBST(vector v, int start, 
                int end)
{
    sort(v.begin(), v.end());
  
    // Base Case
    if (start > end)
        return NULL;
  
    // Get the middle element and make it root
    int mid = (start + end) / 2;
    Node* root = new Node(v[mid]);
  
    // Recursively construct the left subtree
    // and make it left child of root
    root->left = createBST(v, start, mid - 1);
  
    // Recursively construct the right subtree
    // and make it right child of root
    root->right = createBST(v, mid + 1, end);
  
    return root;
}
  
vector preNode, vec;
  
// A utility function to print
// preorder traversal of BST
vector preOrder(Node* node)
{
    // Root Left Right
    if (node == NULL) {
        return vec;
    }
    preNode.push_back(node->data);
    preOrder(node->left);
    preOrder(node->right);
    return preNode;
}
  
// Driver Code
int main()
{
    vector v = { 4, 3, 1, 2 };
    Node* root = createBST(v, 0, v.size() - 1);
  
    vector ans = preOrder(root);
    for (auto i : ans) {
        cout << i << " ";
    }
    return 0;
}

输出

PreOrder Traversal of constructed BST 
4 2 1 3 6 5 7 

时间复杂度： O(N * logN)
辅助空间： O(N) 创建树