返回與給定前序遍歷preorder 相匹配的二叉搜尋樹（binary search tree）的根結點。

(回想一下，二叉搜尋樹是二叉樹的一種，其每個節點都滿足以下規則，對於node.left的任何後代，值總 < node.val，而 node.right 的任何後代，值總 > node.val。此外，前序遍歷首先顯示節點node 的值，然後遍歷 node.left，接著遍歷 node.right。）

題目保證，對於給定的測試用例，總能找到滿足要求的二叉搜尋樹。

示例：

輸入：[8,5,1,7,10,12]
輸出：[8,5,10,1,7,null,12]

提示：

1 <= preorder.length <= 100
1 <= preorder[i]<= 10^8
preorder 中的值互不相同

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/construct-binary-search-tree-from-preorder-traversal
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

因為是二叉搜尋樹，所以陣列排序之後，就是中序遍歷，可以轉化為根據前序和中序，構造二叉樹。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 
 
*/
class Solution {
    public TreeNode bstFromPreorder(int[] preorder) {
        int[] inorder = Arrays.copyOf(preorder, preorder.length);
        Arrays.sort(inorder);
        return buildTree(preorder, inorder);
    }
    
    private TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder == null
 
 || preorder.length == 0) {
            return null;
        }
        int length = preorder.length - 1;
        TreeNode node = new TreeNode(preorder[0]);
        find(preorder, inorder, node, 0, length, 0, length);
        return node;
    }

    private void find(int[] preorder, int[] inorder, TreeNode node, int st, int end, int st2, int end2) {
        if (st > end) {
            return;
        }
        int value = preorder[st];
        int split = st2;
        for (int j = st2; j <= end2; j++) {
            if (inorder[j] == value) {
                split = j;
                break;
            }
        }
        int leftLength = split - st2;
        if (leftLength != 0) {
            TreeNode l = new TreeNode(preorder[st + 1]);
            node.left = l;
            find(preorder, inorder, l, st + 1, st + leftLength, st2, split - 1);
        }
        if (split != end2) {
            TreeNode r = new TreeNode(preorder[st + 1 + leftLength]);
            node.right = r;
            find(preorder, inorder, r, st + 1 + leftLength, end, split + 1, end2);
        }
    }
}