根据给定的遍历构造BST |组合3(朴素方法)

给定二元搜索树的遍历顺序，构造BST。
例如，如果给定的遍历为{10，5，1，7，7，40，50}，则输出应为下一棵树的根。

10
   /   \
  5     40
 /  \      \
1    7      50

在之前的文章中我们讨论了构建二叉搜索树的方法，这是在给定遍历遍历的情况下构建二叉搜索树的另一种方法。

我们知道，BST的有序遍历会以非递减的方式给出元素。因此，我们可以对给定的遍历排序进行排序，以获得二叉搜索树的有序遍历。

在本文中，我们已经学习了在给定预序和有序遍历时构造树的方法。现在，我们将使用相同的方法来构造BST。

CPP

#include
using namespace std;
 
// A BST node has data, pointer to left
// child and pointer to right child
struct Node {
    int data;
    Node *left, *right;
};
 
// A utility function to create new node
Node* getNode(int data)
{
    Node* temp = new Node();
    temp->data = data;
    temp->left = temp->right = NULL;
 
    return temp;
}
 
/* Recursive function to construct BST
Inorder traversal in[] and Preorder traversal
pre[]. Initial values of inStart and inEnd should be
0 and n -1.*/
Node* buildBTRec(int in[], int pre[], int inStart,
            int inEnd, unordered_map& m)
{
    static int preIdx = 0;
    if (inStart > inEnd)
        return NULL;
 
    // Pick current node from Preorder traversal
    // using preIndex and increment preIndex
    int curr = pre[preIdx];
    ++preIdx;
 
    Node* temp = getNode(curr);
 
    // If this node has no children then return
    if (inStart == inEnd)
        return temp;
 
    // Else find the index of this node in
    // inorder traversal
    int idx = m[curr];
 
    // Using this index construct left and right subtrees
    temp->left = buildBTRec(in, pre, inStart, idx - 1, m);
    temp->right = buildBTRec(in, pre, idx + 1, inEnd, m);
 
    return temp;
}
 
// This function mainly creates a map to store
// the indices of all items so we can quickly
// access them later.
Node* buildBST(int pre[], int n)
{
    // Copy pre[] to in[] and sort it
    int in[n];
    for (int i = 0; i < n; i++)
        in[i] = pre[i];
    sort(in, in + n);
 
    unordered_map m;
    for (int i = 0; i left);
    cout 

---

Python3

# A BST node has data, pointer to left
# child and pointer to right child
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None
 
# /* Recursive function to construct BST
# Inorder traversal in[] and Preorder traversal
# pre[]. Initial values of inStart and inEnd should be
# 0 and n -1.*/
def buildBTRec(inn, pre, inStart, inEnd):
    global m, preIdx
 
    if (inStart > inEnd):
        return None
 
    # Pick current node from Preorder traversal
    # using preIndex and increment preIndex
    curr = pre[preIdx]
    preIdx += 1
 
    temp = Node(curr)
 
    # If this node has no children then return
    if (inStart == inEnd):
        return temp
 
    # Else find the index of this node in
    # inorder traversal
    idx = m[curr]
 
    # Using this index construct left and right subtrees
    temp.left = buildBTRec(inn, pre, inStart, idx - 1)
    temp.right = buildBTRec(inn, pre, idx + 1, inEnd)
 
    return temp
 
# This function mainly creates a map to store
# the indices of all items so we can quickly
# access them later.
def buildBST(pre, n):
    global m
     
    # Copy pre[] to in[] and sort it
    inn=[0 for i in range(n)]
 
    for i in range(n):
        inn[i] = pre[i]
 
    inn = sorted(inn)
 
    for i in range(n):
        m[inn[i]] = i
 
    return buildBTRec(inn, pre, 0, n - 1)
 
def inorderTraversal(root):
    if (root == None):
        return
    inorderTraversal(root.left)
    print(root.data, end = " ")
    inorderTraversal(root.right)
 
# Driver Program
if __name__ == '__main__':
    m,preIdx = {}, 0
    pre = [100, 20, 10, 30, 200, 150, 300]
    n = len(pre)
 
    root = buildBST(pre, n)
 
    # Let's test the built tree by printing its
    # Inorder traversal
    print("Inorder traversal of the tree is")
    inorderTraversal(root)
 
# This code is contributed by mohit kumar 29

输出：

Inorder traversal of the tree is 
10 20 30 100 150 200 300

时间复杂度：排序使用O(nlogn)时间进行排序和使用预排序构造，而顺序遍历则花费线性时间。因此，上述解决方案的总体时间复杂度为O(nlogn)。

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。