二叉树所有节点的总和

Question

I'm trying to write a program to calculate the sum of all nodes (including the root) in a Binary Tree (not a Binary Search Tree) represented by a list of lists. I conceptually understand that approaching this recursively is the best way to do it but just cannot figure out the code. So far, my code is:

class BinaryTree:
    def __init__(self,rootObj, leftChild = None, rightChild = None):
        self.key = rootObj
        self.leftChild = None
        self.rightChild = None
        self.node=[rootObj, leftChild, rightChild]
    def getrightChild(self):
        return self.rightChild
    def getleftChild(self):
        return self.leftChild
    def setRootObj(self,obj):
        self.key = obj
    def getRootObj(self):
        return self.key
    def sumTree(BinaryTree):
        if BinaryTree is None: return 0
        return sumTree(BinaryTree.leftChild) \ 
             + sumTree(BinaryTree.rightChild)\
             + BinaryTree.rootObj

print(sumTree([8,[],[]]))
print(sumTree([9, [6, [ ], [ ]], [65, [ ], [ ]]]))

Answer 1

Be careful,

self.key = rootObj
self.leftChild = None
self.rightChild = None

are object attributes, so you can't access them with through your class directly. You have to create an instance like

obj = BinaryTree(...)

and then call the method

obj.sumTree(...)

To your sum algorithm, the easiest way to calculate the sum your way would be something like this:

class BinaryTree:       

    @classmethod
    def calc_sum(cls, list_tree):
        print(list_tree)
        if list_tree:
            left_node_value = BinaryTree.calc_sum(list_tree[1])
            right_node_value = BinaryTree.calc_sum(list_tree[2])
            return list_tree[0] + left_node_value + right_node_value
        return 0        

value = BinaryTree.calc_sum([9, [6, [ ], [ ]], [65, [ ], [ ]]])
print(value)

Answer 2

Well, from what I read from this code, your recursive algorithm is correct. However, there are many syntax mistakes as well as other, semantic mistakes in it that make it impossible to run correctly.

Here is what I see:

• You created a BinaryTree class, but you never created an instance of it. sumTree([...]) tries to calculate that sum of a list, which will not work, because you want it to do it for a BinaryTree object. You need to parse that list and create an instance of BinaryTree first. (Like tree = BinaryTree(*write your list here*) maybe. But you need to make your __init__() method allow that passing of the list, of course. See next point.)
• Your __init__() method takes BinaryTree objects as parameters, so there is no parsing of your lists.
• Within the __init__() method, you set both children to None , so no node will ever have child nodes.
• When calling the sumTree() method, you need to specify the context. It needs to be BinaryTree.sumTree(..) . You still need to create the Binary tree instance that shall be passed to the sumTree method, though.
• Within the sumTree() method, you try to access the rootObj member - which does not exist, because you called it key .

Besides the errors, I'd like to point out some "code smells", if you like.

• You should rename the parameter of the sumTree() method to something different ot the class name.
• In python, there is no need for Getter-methods. You can access the members directly. If you still wish to define more complex get/set behaviour, you should have a look at python properties .
• The member node is never used.

Answer 3

You don't need all the getters . You can simply use object accessor methods, eg tree_a.left_child . Secondly, you didn't create a BinaryTree out of your children, meaning that it doesn't make sense to run sum_tree on them. Read through the following code, and make sure that you understand what's going on.

Pretty sure that what you actually want, is this

class BinaryTree:
    def __init__(self, root, left_child=None, right_child=None):
        self.root = root
        self.left_child = None if not left_child else BinaryTree(*left_child)
        self.right_child = None if not right_child else BinaryTree(*right_child)
        self.node = [root, left_child, right_child]

    def set_root(self, root):
        self.root = root

    def sum_tree(self):
        tree_sum = 0
        if self.left_child:
            tree_sum += self.left_child.sum_tree()
        if self.right_child:
            tree_sum += self.right_child.sum_tree()

        return tree_sum + self.root

tree_a = BinaryTree(8)
tree_b = BinaryTree(9, [6, [], []], [65, [], []])
print(tree_a.sum_tree())
# 8
print(tree_b.sum_tree())
# 80
print(tree_b.left_child.node)
# [6, [], []]