Algorithm 给出了n个元素1,2和#x2026；上的二元搜索树的后序遍历P；，N

给出了n个元素1,2，…，n上二叉搜索树的后序遍历p。您必须确定唯一的二叉搜索树，该树将P作为其后序遍历。最有效的算法的时间复杂度是多少

A.Θ（logn）

B.Θ（n）

C.Θ（nlogn）

D.上述各项均不适用，因为无法唯一确定树

我的理解是：

根据给定的后序遍历，我们可以计算lg（n）时间内的有序遍历。由于我们现在计算了顺序遍历，我们可以将元素分成两部分，因为根元素将是我们的枢轴元素

我不知道我是否理解正确，你能帮我把这个概念形象化吗。

它必须是

Θ（nlogn）

。您必须至少遍历n个节点，然后构建二叉树

预排序遍历的示例如下所示。您可以对postorder应用类似的逻辑。它使用递归

逻辑是，当我们从左到右迭代时，我们将首先得到小于第一个节点的元素集。这些节点将位于节点的左侧。其余的都在右边

例如：

这方面的Java代码：

public TreeNode bstFromPreorder(int[] preorder) {
    if(preorder == null) { return null; }

    if(preorder.length == 0) { return null; }

    TreeNode root = new TreeNode(preorder[0]);

    if(preorder.length == 1) {
        root.left = null;
        root.right = null;
        return root;
    }

    int leftStart = 0;
    if( preorder[1] < preorder[0]) {
        leftStart = 1;
    }

    int rightStart = leftStart+1;

    while(rightStart < preorder.length && preorder[rightStart] < preorder[0]) {
        rightStart++;
    }

    int[] leftPre = new int[0];
    if(leftStart != 0) { 
        leftPre = getSubArray(preorder, leftStart, rightStart);
    }
    int[] rightPre = getSubArray(preorder, rightStart, preorder.length);

    TreeNode leftNode = bstFromPreorder(leftPre);
    TreeNode rightNode = bstFromPreorder(rightPre);

    root.left = leftNode;
    root.right = rightNode;

    return root;  
}


private int[] getSubArray(int[] nums, int leftStart, int rightStart) {
    int[] ans = new int[rightStart - leftStart];

    for(int i = leftStart; i < rightStart; i++) {
        ans[i - leftStart] = nums[i];
    }
    return ans; 
}

公共树节点bstFromPreorder（int[]preorder）{
if（preorder==null）{returnnull；}
如果（preorder.length==0）{return null；}
树节点根=新树节点（前序[0]）；
if（preorder.length==1）{
root.left=null；
root.right=null；
返回根；
}
int leftStart=0；
if（预订单[1]<预订单[0]）{
leftStart=1；
}
int rightStart=leftStart+1；
while（rightStart

public TreeNode bstFromPreorder(int[] preorder) {
    if(preorder == null) { return null; }

    if(preorder.length == 0) { return null; }

    TreeNode root = new TreeNode(preorder[0]);

    if(preorder.length == 1) {
        root.left = null;
        root.right = null;
        return root;
    }

    int leftStart = 0;
    if( preorder[1] < preorder[0]) {
        leftStart = 1;
    }

    int rightStart = leftStart+1;

    while(rightStart < preorder.length && preorder[rightStart] < preorder[0]) {
        rightStart++;
    }

    int[] leftPre = new int[0];
    if(leftStart != 0) { 
        leftPre = getSubArray(preorder, leftStart, rightStart);
    }
    int[] rightPre = getSubArray(preorder, rightStart, preorder.length);

    TreeNode leftNode = bstFromPreorder(leftPre);
    TreeNode rightNode = bstFromPreorder(rightPre);

    root.left = leftNode;
    root.right = rightNode;

    return root;  
}


private int[] getSubArray(int[] nums, int leftStart, int rightStart) {
    int[] ans = new int[rightStart - leftStart];

    for(int i = leftStart; i < rightStart; i++) {
        ans[i - leftStart] = nums[i];
    }
    return ans; 
}