Leetcode 樹の簡單題訓練集合（107 226 257 235 404） python

107. 二叉樹的層次遍歷 II

之前做過一遍，不過覺得這個題挺有意思的，就複習了一遍
基本思想就是建立一個記錄每層節點的列表，建立一個記錄每層節點值的列表，然後pop出節點，記錄值

class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root: return root
        res = []
        nodes = [root]
        while nodes:
            tree = nodes
            nodes = []
            layer = []
            while tree:
                node = tree.pop(0) #這個地方pop只能從前pop，我嘗試了pop最後一個然後先append right 再append left，這樣會出錯
                layer.append(node.val)
                if node.left: nodes.append(node.left)
                if node.right: nodes.append(node.right)
            res.append(layer)
        return res[::-1]  

226. 翻轉二叉樹

遞歸

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if root:
            root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
        return root

257. 二叉樹的所有路徑

class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        if not root: return root
        res = []
        path_node = ''
        def path(path_node, node):
            if node:
                path_node = path_node + str(node.val) + '->'
                if node.left and not node.right:
                    path(path_node, node.left)
                elif node.right and not node.left:
                    path(path_node, node.right)
                else: #這裏包含了有左右節點的節點和葉子節點兩種情況
                    path(path_node, node.left)
                    path(path_node, node.right)
            else:
                res.append(path_node[:-2])
        path(path_node, root)
        return set(res)

235. 二叉搜索樹的最近公共祖先

複習一下二叉搜索樹特性：
左孩子值<父節點值<右孩子值
且右側的值一定大於左側的值（不會出現第三層最右側節點的左孩子大於第三層左側節點的情況）
完了之後就往下搜，注意輸入全部都是node就行了

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if p.val == q.val: return q.val
        if p.val > q.val: p, q = q, p
        p = p.val
        q = q.val
        while root:
            if p <= root.val <= q:
                return root
            elif q < root.val: 
                root = root.left
            elif p > root.val:
                root = root.right   

404. 左葉子之和

我一開始看成了所有左節點之和，寫了好久啊後來才發現是左葉子之和LOL

class Solution(object):
    def sumOfLeftLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root: return 0
        if not root.left and not root.right: return 0
        left_val = 0
        def left_sum(left_val, node, flag):
            if node.left: 
                left_val = left_sum(left_val, node.left, 1)
            if node.right:
                left_val = left_sum(left_val, node.right, 0)
            if not node.left and not node.right and flag: 
                left_val = left_val + node.val
            return left_val
        return left_sum(left_val, root, 0)