Python 用树叶做一棵树

嘿，我正在准备考试，我需要一些帮助。 任务是从叶子值数组（从左到右）构建一个二叉和树（父节点键是子节点键的和），叶子值数组的长度始终为2^n。我首先将数组转换为节点数组。然后，我创建了一个递归函数，该函数将对组合起来，并在新创建的节点数组上调用自己。有没有更好的方法来完成这项任务？也许是一个“到位”的？ e、 g

输入：[1,2,3,4]

输出：

---

通常是这样的：

def buildSumTree(array):
    return buildSumTree2(array, 0, len(array))

def buildSumTree2(array, startpos, length):
    if length < 1:
        return None
    if length == 1:
        return makeNode(array[startpos])
    halflen = length/2
    l = buildSumTree2(array, startpos, halflen)
    r = buildSumTree2(array, startpos+halflen, length-halflen)
    n = makeNode(l.key + r.key)
    n.left = l
    n.right = r
    return n

def buildSumTree（数组）：
返回buildSumTree2（数组，0，len（数组））
def buildSumTree2（阵列、起始点、长度）：
如果长度小于1：
一无所获
如果长度==1：
返回makeNode（数组[startpos]）
半透镜=长度/2
l=BuildSumtre2（阵列、启动、半透镜）
r=BuildSumtre2（阵列、起始点+半透镜、长度半透镜）
n=makeNode（左键+右键）
n、 左=l
n、 右=r
返回n

以下代码从叶子到根构建树。它重复地将两个子节点连接到它们新创建的父节点，直到只剩下一个节点

class Node:
    def __init__(self, left, right):
        self.left = left
        self.right = right
        self.value = sum(n.value for n in (left, right) if n is not None)

    @classmethod
    def create_leaf(cls, value):
        leaf = cls(None, None)
        leaf.value = value
        return leaf


INPUT = [1, 2, 3, 4]

nodes = [Node.create_leaf(v) for v in INPUT]
while len(nodes) > 1:
    inodes = iter(nodes)
    nodes = [Node(*pair) for pair in zip(inodes, inodes)]

root_node = nodes[0]

---

成对迭代基于：

此实现只存储叶子，不存储其他内容，因此不使用额外的内存来存储节点。它也不会改变叶子，即不执行任何更改，只执行读取操作。所有其他信息都是动态计算的。目前，输出是基本的，每深度一行

import math

class SumTree:

  def __init__(self, leaves):
    self.leaves = leaves

  def nodeAt(self, i, j):
    if i < self.height() - 1:
      return self.nodeAt(i+1, 2*j) + self.nodeAt(i+1, 2*j+1)
    elif i == self.height() - 1:
      return self.leaves[j]
    else:
      raise 'no nodes exists at this depth.'

  def nodesAtDepth(self, i):
    return [self.nodeAt(i, j) for j in range(self.widthAtDepth(i))]

  def maxWidth(self):
    return self.widthAtDepth(self.height() - 1)

  def widthAtDepth(self, i):
    return 2 ** i

  def height(self):
    return math.floor(math.log(len(self.leaves), 2)) + 1

  def __str__(self):
    result = ''
    width = self.maxWidth()
    for i in range(self.height()):
      result += '{}\n'.format(self.nodesAtDepth(i))
    return result

tree = SumTree(list(range(1, 5)))
print('leaves', tree.leaves)
print('height', tree.height())
print(tree)

导入数学
SumTree类：
定义初始（自我，离开）：
self.leaves=树叶
def nodeAt（self、i、j）：
如果i

---

请问您在这里所说的

就地
是什么意思？它不需要额外的内存。不同于我的解决方案，每个递归级别都创建一个新数组。数组是要创建的SumTree的最底层的值。其次，从哪里获取数组？它对元素的组织方式是否具有某种逻辑结构？你能举一个数组的例子吗？你打算显示预期的输入/输出吗？
class Node:
    def __init__(self, left, right):
        self.left = left
        self.right = right
        self.value = sum(n.value for n in (left, right) if n is not None)

    @classmethod
    def create_leaf(cls, value):
        leaf = cls(None, None)
        leaf.value = value
        return leaf


INPUT = [1, 2, 3, 4]

nodes = [Node.create_leaf(v) for v in INPUT]
while len(nodes) > 1:
    inodes = iter(nodes)
    nodes = [Node(*pair) for pair in zip(inodes, inodes)]

root_node = nodes[0]

import math

class SumTree:

  def __init__(self, leaves):
    self.leaves = leaves

  def nodeAt(self, i, j):
    if i < self.height() - 1:
      return self.nodeAt(i+1, 2*j) + self.nodeAt(i+1, 2*j+1)
    elif i == self.height() - 1:
      return self.leaves[j]
    else:
      raise 'no nodes exists at this depth.'

  def nodesAtDepth(self, i):
    return [self.nodeAt(i, j) for j in range(self.widthAtDepth(i))]

  def maxWidth(self):
    return self.widthAtDepth(self.height() - 1)

  def widthAtDepth(self, i):
    return 2 ** i

  def height(self):
    return math.floor(math.log(len(self.leaves), 2)) + 1

  def __str__(self):
    result = ''
    width = self.maxWidth()
    for i in range(self.height()):
      result += '{}\n'.format(self.nodesAtDepth(i))
    return result

tree = SumTree(list(range(1, 5)))
print('leaves', tree.leaves)
print('height', tree.height())
print(tree)