Python 计算二叉搜索树中的节点数

我正试图打印我的二叉搜索树的大小。但是，我的代码现在正在打印每个节点的级别。我觉得好像我把我的

count+=1

放错地方了，或者可能是别的什么东西。我想知道是否有人能为我做一双额外的眼睛，并给我一个如何解决这个问题的提示

输出：

3
3
2
3
3
2
1

预期产出：

7

我的代码：

def BST_size(root, count = 0):
    if root is None:
        print "size -1 (Null value in root)"
    if root is not None:
        count += 1
        if root.left is not None:
            BST_size(root.left, count)
        if root.right is not None:
            BST_size(root.right, count)
    print count 

额外部分：

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


def BST_Insert(root, node):     # root --> root of tree or subtree!
    if root.value is None:
        root = node             # beginning of tree
    else:
        if root.value > node.value:     # go to left
            if root.left is None:
                root.left = node
            else:
                BST_Insert(root.left, node)

        if root.value < node.value:    # go to right
            if root.right is None:
                root.right = node
            else:
                BST_Insert(root.right, node)

r = Node(4)
# left
a = Node(2)
b = Node(1)
c = Node(3)
# right
d = Node(8)
e = Node(6)
f = Node(10)

BST_Insert(r, a)
BST_Insert(r, b)
BST_Insert(r, c)
BST_Insert(r, d)
BST_Insert(r, e)
BST_Insert(r, f)

类节点：
定义初始值（自身，值）：
self.right=无
self.left=无
自我价值=价值
def BST_Insert（根，节点）：#根-->树或子树的根！
如果root.value为无：
根=节点#树的开头
其他：
如果root.value>node.value:#向左
如果root.left为无：
root.left=节点
其他：
BST_插入（root.left，节点）
如果root.value

有两种方法可以做到这一点

---

最简单的方法是

返回每个递归调用的计数，而不仅仅是
打印它，然后递增：

def BST_size(root):
    if root is None:
        return -1
    if root is not None:
        if root.left is not None:
            return 1 + BST_size(root.left)
        if root.right is not None:
            return 1 + BST_size(root.right)

def print_BST_size(root):
    size = BST_size(root)
    if size == -1:
        print "size -1 (Null value in root)"
    else:
        print "size", size

但是，这仍然不起作用，因为您只遍历左侧或右侧，而不是两者。你想要的是：

    count = -1
    if root is not None:
        if root.left is not None:
            count += BST_size(root.left)
        if root.right is not None:
            count += BST_size(root.right)
    return count


不过，看起来您正在尝试使用尾部递归样式的累加器。在Python中这样做毫无意义，因为Python不会优化尾部调用，但对于其他语言和理论原因来说，这是一项非常有用的技能，所以

这里的问题是，您需要所有递归调用共享相同的值，这意味着您需要一个可变值。因此，您可以从
[0]
开始而不是
0
，然后执行
count[0]+=1
而不是
count+=1

或者，您可以重新排列代码，使其不可变地使用
count
，而是将更新后的计数从一端传递到另一端


不管怎样，您的代码都有另一个问题。递归的基本情况是
root
是
None
。但您也将其作为一个特例，打印-1而不是0。你不能两全其美。
这里有一个简短的答案

def BST_size(root):
    if root is None:
        return 0
    else:
        return BST_size(root.left) + BST_size(root.right) + 1

print "Size is: " + str(BST_size(r))

必须执行tree-treversal，其中函数返回+1（自身）以下的节点数

伪代码：

def counter(t):
  rCount = counter(t.right)
  lCount = counter(t.left)
  return 1 + rCount + lCount

您可以使用以下内容：

def countNodes(root):
    count = 1
    if root is None:
        return -1
    if root is not None:
        if root.left is not None:
            count += countNodes(root.left)
        if root.right is not None:
            count +=  countNodes(root.right)
    return count

然后像下面那样调用它：

print ("\nCount of Nodes :" + str(countNodes(root)))

count
是不可变的。@Veedrac我对python还是新手，但count是不可变的，因为count=0我把它作为一个函数参数？“6个新的答案；点击加载“有人说fizzbuzz了吗？”作为旁注，在你的所有代码中，如果foo:
你都在做
，如果不是foo:
。你不需要这样做；只需使用
else:
。除了更容易阅读，并且不重复评估相同的条件外，它还使否定您的条件和遗漏中间情况变得不可能。抱歉，最终发布了与您相同的答案。抱歉，这可能是一个初学者问题，但您提供给我的函数只接受1个参数，但是，当您在if语句中再次递归调用该函数时，您给出了2。
count
参数是否在函数中传递？新的
count
在哪里更新？@Liondancer:对不起，在自顶向下的版本中，不需要
count
参数，所以我不应该向下传递它。我将编辑答案以解决此问题。抢手货
def countNodes(root):
    count = 1
    if root is None:
        return -1
    if root is not None:
        if root.left is not None:
            count += countNodes(root.left)
        if root.right is not None:
            count +=  countNodes(root.right)
    return count

print ("\nCount of Nodes :" + str(countNodes(root)))