Leetcode 刷题笔记1 二叉树part03

leetcode110 平衡二叉树

本次学习以递归的应用，递归三要素：传入参数返回值、终止条件、循环逻辑

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if self.getHeight(root) != -1:
            return True
        else:
            return False
    def getHeight(self, root: TreeNode) -> int:
        if not root:
            return 0
        if(left_height := self.getHeight(root.left)) == -1:
            return -1
        if (right_height := self.getHeight(root.right)) == -1:
            return -1
        if abs(left_height - right_height) > 1:
            return -1 
        else:
            return  1 + max(left_height, right_height)

leetcode 257 二叉树的所有路径

本题学习到叶子节点的判断以及初识回溯

class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        result = []
        path = []
        if not root:
            return result
        self.traverlsal(root, path, result)
        return result 
    def traverlsal(self, cur, path, result):
        path.append(cur.val)
        if not cur.left and not cur.right:
            sPath = '->'.join(map(str,path))
            result.append(sPath)
            return
        if cur.left:
            self.traverlsal(cur.left, path, result)
            path.pop()
        if cur.right:
            self.traverlsal(cur.right, path, result)
            path.pop()

leetcode 404 左叶子之和

本题主要学习到左叶子的代码表示（如何判断左右叶子）

class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        if root.left is None and root.right is None:
            return 0
        leftValue = self.sumOfLeftLeaves(root.left)
        if root.left and not root.left.left and not root.left.right:
            leftValue = root.left.val
        rightValue = self.sumOfLeftLeaves(root.right)
        sumValue = leftValue + rightValue
        return sumValue

leetcode 513.找树左下角的值

本题层序遍历很简单

递归有点难以想到思路

关于递归需要多理解多练习

from collections import deque
class Solution:
    def findBottomLeftValue(self, root):
        if root is None:
            return 0
        queue = deque()
        queue.append(root)
        result = 0
        while queue:
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                if i == 0:
                    result = node.val
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return result

递归法

class Solution:
    def findBottomLeftValue(self, root: TreeNode) -> int:
        self.max_depth = float('-inf')
        self.result = None
        self.traversal(root, 0)
        return self.result
    
    def traversal(self, node, depth):
        if not node.left and not node.right:
            if depth > self.max_depth:
                self.max_depth = depth
                self.result = node.val
            return
        
        if node.left:
            self.traversal(node.left, depth+1)
        if node.right:
            self.traversal(node.right, depth+1)