Python树数据结构

我已经编写了这段代码来计算树中的节点数，但是我没有得到正确的答案

计数不会在每次返回时都被添加。我不知道为什么。我得到的答案是

1+1=2

。 只有一次盘点进入账户

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
    def size(a):
       count1 = 0
       count2 = 0
    if not a:
        return 0
    else:
       size(a.left)
       count1 +=1
       size(a.right)
       count2 +=1
   return count1+count2

   root1 = Node(1)
   root2 = Node(1)
   root1.left = Node(2)
   root1.right = Node(3)
   root1.left.left = Node(4)
   root1.left.right = Node(5)
   root1.left.right.left=Node(6)

   p=size(root1)
   print(p)

---

正如注释中所述，正确的缩进在Python中是至关重要的

除了缩进问题，您的

size

函数实际上会对每个节点计数两次，但您不使用递归调用的返回值，因此它们不会被添加到计数中

这是您的代码的修复版本

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Find the size of the tree rooted at `a`
def size(a):
    if not a:
        return 0
    # count is 1 for this node + the sizes of the subtrees
    count = 1 + size(a.left) + size(a.right)
    return count

# Build a tree
root1 = Node(1)
root1.left = Node(2)
root1.right = Node(3)
root1.left.left = Node(4)
root1.left.right = Node(5)
root1.left.right.left=Node(6)

# Print its size
p = size(root1)
print(p)

输出

6

在本例中，我包括了两种检索大小的方法，一种是跟踪成员变量，另一种是根据树中的节点数计算大小

成员变量方式更快，建议使用，因为它是获取树大小的单个操作。使用该方法时，它会对每个节点进行计数。这使得它的时间复杂度为O（n），而成员变量访问的时间复杂度为O（1）

但是，要使大小变量准确，您必须在如何向树中添加新节点方面保持一致，例如，如果您说tree.root.left=Node（6），这不会增加大小变量，那么它将不准确

此示例是BST（二进制搜索树）的基本实现，BST具有一个属性，该属性表示树中的节点必须具有0到2个子节点，左侧节点必须小于该节点，右侧节点必须大于该节点。小于和大于取决于节点中的数据类型

---

我希望这个例子能有所帮助。

您调用的是

size（a.left）

和

size（a.right）

，但您没有将此结果存储在任何要使用的地方。正如Fernando所说，您需要将count变量传递给size方法来跟踪大小，或者，您可以让Tree类保留一个随着添加节点而递增的大小变量。请修复缩进。@chatton您好，先生，请编辑代码并粘贴到这里。这对我很有帮助。我在C或C++中发现压痕错误，这只会让你的代码难以阅读。在python中出错会完全改变其含义。如图所示的代码将从类定义中返回，这将引发语法错误。

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None


class Tree:
    def __init__(self):
        self.root = None
        self.size = 0

    def add_node(self, data):
        self.root = self._add_node(data, self.root)
        self.size += 1  # we're about to add a new node, so we have one more element!

    def _add_node(self, data, node):
        node_to_add = Node(data)
        if not node:
            return node_to_add

        if node.data >= node_to_add.data:
            node.left = self._add_node(data, node.left)
        elif node.data < node_to_add.data:
            node.right = self._add_node(data, node.right)

        return node

    def print_tree(self):
        self._print_tree(self.root)

    def _print_tree(self, starting_node):
        if starting_node is None:
            return

        self._print_tree(starting_node.left)
        print starting_node.data,
        self._print_tree(starting_node.right)

    def count_number_nodes(self):
        return self._count_number_of_nodes(self.root)

    def _count_number_of_nodes(self, starting_node):

        num = 1
        if starting_node.left is not None:
            num += self._count_number_of_nodes(starting_node.left)

        if starting_node.right is not None:
            num += self._count_number_of_nodes(starting_node.right)

        return num


tree = Tree()
tree.add_node(10)
tree.add_node(42)
tree.add_node(1)
tree.add_node(-14)
tree.add_node(32)
tree.add_node(12)

print "printing in order traversal of tree (smallest to biggest)"
tree.print_tree()
print
print "size from member variable: " + str(tree.size)
print "size from method call: " + str(tree.count_number_nodes())

printing in order traversal of tree (smallest to biggest)
-14 1 10 12 32 42
size from member variable: 6
size from method call: 6