Tree 只给出一次遍历的所有可能的二叉树

给定一个二叉树（不一定是BST）的只按序遍历（或只按后序/前序遍历），一个代码如何在给定此遍历的情况下生成所有可能的二叉树

我知道给定“n”个节点可能的二叉树的数量是（2^n）-n，但如果我们可以访问树的单个遍历，我们如何编写此算法？

递归执行

def emptyTree():
    return None

def node(l,d,r):
    return (l,d,r)

def singleton(x):
    return (emptyTree(),x,emptyTree())

def allBT(trav,length):
    if length == 0:
        return [emptyTree()]
    if length == 1:
        return [singleton(trav[0])]
    trees = [node(emptyTree(),trav[0],right) for right in allBT(trav[1:],length-1)]
    trees += [node(left,trav[i],right) for i in xrange(1,length-1) for left in allBT(trav[:i],i) for right in allBT(trav[i+1:],length-i-1)]
    trees += [node(left,trav[length-1],emptyTree()) for left in allBT(trav[:length-1],length-1)]
    return trees

def allBinaryTrees(trav):
    return allBT(trav,len(trav))

顺便说一下，你的二叉树的数目是错误的。只有一棵树有0个节点，一棵树有1个节点，还有2棵树有两个节点。递归是

T(n) = \sum_{i = 0}^{n-1} T(i)*T(n-i-1)

因为我们可以选择每个项目作为根，并且可以将之前

i

节点的每个可能性与之后

n-i-1

节点的每个可能性相结合。因此

T（3）=5，T（4）=14，T（5）=42，T（6）=132，…

功能节点（数据）{
function Node(data) {
    this.data = data;
    this.left = null;
    this.right = null;
}

function Tree(arr, start = 0, end = arr.length - 1) {
    let trees = [];
    if (start > end) trees.push(null);

    for (let i = start; i <= end; i++) { // consider 0 to end all as root node one by one.
        let leftTree = Tree(arr, start, i - 1); // find left subtrees possiblr for node i
        let rightTree = Tree(arr, i + 1, end); // find right subtrees possiblr for node i

        // make all combinations of leftTree and rightTree
        for (let j = 0; j < leftTree.length; j++)
            for (let k = 0; k < rightTree.length; k++) {
                // cretate result tree and push in result arr.
                let root = new Node(arr[i]);
                root.left = leftTree[j];
                root.right = rightTree[k];
                trees.push(root);
            }
    }
    return trees;
}

let result = Tree([4, 5, 7]);

console.log(result);

//Output
// 4 5 7
// 4 7 5
// 5 4 7
// 7 4 5
// 7 5 4 

这个数据=数据；
this.left=null；
this.right=null；
}
函数树（arr，start=0，end=arr.length-1）{
让树=[]；
if（开始>结束）trees.push（null）；
对于（让我=开始；我这个公式怎么不正确？（2^n）-n。你给出的数字都是通过应用这个公式获得的。另外，你能发布伪代码吗？我不太明白你是如何生成所有可能性的。这些数字与
2^n-n
不一致，例如
14=t（4）！=12=2^4-4
。他们只同意
n是的，对不起，但我不太懂python。类似C的代码会非常有帮助。这就是我所说的运气。我刚想把它打出来，然后就来了。我希望它足够好，否则我可以充实一下。