我有一个代表二叉树的数字列表。第一个数字的处理方式与其他数字不同，它是根。其余的＆＃34;其余的＆＃34;数字，有些会高于根，有些会更低。命令较高的数字向左移动，而较年轻的数字则命令向右移动。例如：
list = [5,7,6,8,9,2,1,3,4]
root = 5
higher = [7,6,8,9] #in order of appearance
root = 7
higher = [8,9]
lower = [6]
lower = [2,1,3,4] #in order of appearance
root = 2
higher = [3,4]
lower = [1]
在这种情况下，树看起来像这样：
5
-------------| |--------------
| |
7 2
8--------| |-------6 3-----| |-----1
---| ---|
9 4
我希望找到一种方法来模拟列表[5,7,6,8,9,2,1,3,4]可以排列的可能组合的数量，以便生成相同的二叉树。解决方案绝对是递归的，因为在＆＃34;更高的＆＃34;并且＆＃34;降低＆＃34;数字，它们可以被打破更多。
确定所有数字的排列方式可以通过分解树来开始，就像我们对上面的列表所做的那样。
higher = [7,6,8,9]
但higher列表不需要保留[7,6,8,9]的顺序。只有那些不是另一棵树的父母的根以上的项目需要按照出现的顺序保存。由于6和8都是7的子节点，因此它们是可互换的，但9必须在8之前，因为它是它的子节点。所以基本上重新排列此列表的唯一规则是：
因此有三种组合。
[7,6,8,9]
[7,8,6,9]
[7,8,9,6]
所有这些都可以分解为相同的子树，因此我们的条件得到满足，现在我们可以查看元素列表lower而不是主根。
lower = [2,1,3,4]
下层列表也不需要保留其顺序，它遵循类似的规则，可以用三种不同的方式编写来生成相同的树：
[2,1,3,4]
[2,3,1,4]
[2,3,4,1]
我们现在有这个信息： - 较低的可以写3种方式 - 可以用3种方式写出更高的
它们可以组合多少种不同的方式来生成同一棵树？这是3 ^ 3吗？还是更多？
看看我知道的数字：
list = [5,7,6,8,2,1,3,4]
如果我列出了每个地点可能出现的数字，那么这就是我最终获得的数据：
列表的第一个元素必须是5，它是根。之后，它必须是2或7，因为其他任何内容都会破坏较高/较低列表的顺序。在那之后，它会变得混乱。
如果第二个数字= 2，则第三个数字可以是三个部分之一，1,3或7。
如果第二个数字= 7，则第三个数字可以是三个中的一个，6,8或2。
在此之后，它扩大得更大，组合变得非常快。我的问题是，有没有办法以有效的方式递归检索总可能组合的数量？我将在python中执行此操作。谢谢。
答案 0 :(得分：1)
根据我的理解，您需要与图表兼容的拓扑订单数量，其中每个节点都有一个弧到其父节点。我将在未经测试的Python中绘制一个解决方案。首先，我们需要一个节点数据类型。
import collections
Node = collections.namedtuple('Node', ('left', 'right'))
树是None（空树）或Node，其中两个字段都是树。
现在，空树的拓扑订单数量为1，即只是空订单。非空树的拓扑顺序数由以下计数参数给出。根始终是第一位的。在根之后，左子树的任意拓扑顺序被任意地用右子树的任意拓扑顺序混洗。因此，公式是三个因素的乘积。
import math
def num_shuffles(left_size, right_size): # binomial coefficient
return (math.factorial(left_size + right_size) //
(math.factorial(left_size) * math.factorial(right_size)))
def num_orders_and_size(tree):
assert isinstance(tree, (type(None), Node))
if tree is None:
return (1, 0)
else:
left_num_orders, left_size = num_orders_and_size(tree.left)
right_num_orders, right_size = num_orders_and_size(tree.right)
return (num_shuffles(left_size, right_size) *
left_num_orders * right_num_orders,
left_size + 1 + right_size)
要从列表构建树，我们使用递归（有更快的方法，但这个方法最简单）。
def tree_from_list(lst):
if not lst:
return None
root = lst[0]
left_lst = [x for x in lst if x > root]
right_lst = [x for x in lst if x < root]
return Node(tree_from_list(left_lst), tree_from_list(right_lst))
答案 1 :(得分：0)
建立在上面的想法......这是生成所有等价排序的python生成器代码。
import collections
Node = collections.namedtuple('Node', ('root','left', 'right'))
def tree_from_list(lst):
if not lst:
return None
root = lst[0]
left_lst = [x for x in lst if x > root]
right_lst = [x for x in lst if x < root]
return Node(root,tree_from_list(left_lst), tree_from_list(right_lst))
def parent(key, tree):
if tree is None:
return -1
elif (tree.left != None) and (tree.left.root == key):
return tree.root
elif (tree.right != None) and (tree.right.root == key):
return tree.root
elif (key > tree.root):
return parent(key, tree.left)
else: return parent(key, tree.right)
def all_insert_after(key, target, seq):
i = seq.index(key)
for j in range(i,len(seq)):
mylist = seq[:j+1] + [target] + seq[j+1:]
yield mylist
def all_equivalent_orderings(seq):
if (len(seq)==1):
yield seq
else:
z = seq[-1]
p = parent(z, tree_from_list(seq))
for a in all_equivalent_orderings(seq[:-1]):
for b in all_insert_after(p,z,a):
yield b
print "Here are all 630 equivalent orderings of [5,7,6,8,9,2,1,3,4]"
for o in all_equivalent_orderings([5,7,6,8,9,2,1,3,4]):
print o