Python LeetCode

Python不熟悉

不同的做法

404. Sum of Left Leaves

这是我的做法，AC。

class Solution(object):
    res = 0
    def recursive(self, root):
        if root == None:
            return
        if root.left != None and root.left.left == None and root.left.right == None:
            self.res += root.left.val
        self.recursive(root.left)
        self.recursive(root.right)
    def sumOfLeftLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.recursive(root)
        return self.res

也可以进行迭代：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution(object):
    def sumOfLeftLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        ## 3rd try: iterative bfs
        if not root:
            return 0
        self.queue = [root]
        self.ans = 0
        while self.queue:
            n = self.queue.pop(0)
            if n.left:
                if n.left.left == None and n.left.right == None:
                    self.ans += n.left.val
                else:
                    self.queue.append(n.left)
            if n.right:
                self.queue.append(n.right)
        return self.ans
        ## 3.2: iterative dfs
        '''
        if not root:
            return 0

        self.res = 0
        self.stack = [root]
        while self.stack:
            node = self.stack.pop()

            if node.left:
                if node.left.left is None and node.left.right is None:
                    self.res += node.left.val
                else:
                    self.stack.append(node.left)
            if node.right:
                self.stack.append(node.right)

        return self.res
        '''
        ## 2nd try with help from discussion: recursive on local variable
        '''
        if root == None:
            return 0
        ans = 0
        if root.left and root.left.left == None and root.left.right == None:
            ans = root.left.val
        return ans + self.sumOfLeftLeaves(root.left) + self.sumOfLeftLeaves(root.right)
        '''
        ## 1st try: recursive on global variable
        '''
        self.ans = 0

        def dfs(root, isLeft):
            if root == None:
                return
            if not root.left and not root.right:
                if isLeft:
                    self.ans += root.val
                return
            dfs(root.left, True)
            dfs(root.right, False)

        dfs(root, False)
        return self.ans
        '''

没有理解题意

563. Binary Tree Tilt

AC版本：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution(object):
    count = 0
    def recursive(self, root):
        if root == None:
            return 0
        left = self.recursive(root.left)
        right = self.recursive(root.right)
        self.count += abs(left - right)
        return root.val + left + right
    def findTilt(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.recursive(root)
        return self.count

加速版本，利用tuple一个保存累积的tilt，一个保存当前结点的子结点的和：

class Solution(object):
    def findTilt(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        (tree_tilt,s)=self.recurTilt(root)
        return tree_tilt
    def recurTilt(self,root):
        #return tree tilt, and tree nodes sum
        if not root:
            return 0,0
        (ltree_tilt,l_sum)=self.recurTilt(root.left)
        (rtree_tilt,r_sum)=self.recurTilt(root.right)
        node_tilt=abs(l_sum-r_sum)
        return (ltree_tilt+rtree_tilt+node_tilt,l_sum+r_sum+root.val)

并不是简单的计算两个结点的值的绝对值，而是将两个结点的子结点的和求绝对值差，比如说下面这个例子：

它计算的过程应该是(5 - 0) + (4 - 0) + ((3 + 5) - (2 + 4)) ，最终的结果是11，所以像我之前没有计算当前结点的两个子结点的和都是错的。

class Solution(object):
    count = 0
    def recursive(self, root):
        if root == None:
            return 0
        if root.left and root.right:
            self.count += abs(root.left.val - root.right.val)
        elif root.left:
            self.count += root.left.val
        elif root.right:
            self.count += root.right.val
        self.recursive(root.left)
        self.recursive(root.right)
    def findTilt(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        self.recursive(root)
        return self.count