代码随想录第十七天：110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和

110.平衡二叉树

自定义一个函数求高度，然后递归，遍历顺序选择后序遍历

若子树不是平衡二叉树，那整棵树一定不是平衡二叉树，所以将这种情况下高度直接返回-1

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.height(root) != -1   # 只要求height得到的是-1，则说明不是平衡二叉树

    def height(self, node):
        """
        求树的高度，若子树不是平衡二叉树，则直接返回-1，否则返回树的高度
        """
        if not node:
            return 0
        leftheight = self.height(node.left)
        if leftheight == -1:
            return -1
        rightheight = self.height(node.right)
        if rightheight == -1:
            return -1
        if abs(leftheight-rightheight) > 1:
            return -1
        return 1+max(leftheight, rightheight)

257. 二叉树的所有路径

回溯不太熟悉

因为还要回来走另一条岔路，所以需要回溯

主要是递归还是难写啊

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def traversal(self, cur, path, res):  # path存放每一条路径，res存放最终结果
        # 中
        path.append(cur.val)
        if not cur.left and not cur.right:  # 到达叶子节点
            s_path = '->'.join(map(str, path))
            res.append(s_path)
            return
        # 左
        if cur.left:
            self.traversal(cur.left, path, res)
            path.pop()  # 回溯
        # 右
        if cur.right:
            self.traversal(cur.right, path, res)
            path.pop()
    
    
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        path = []
        res = []
        if not root:
            return []
        self.traversal(root, path, res)
        return res

404.左叶子之和 

虽然知道怎么遍历，有思路，但是递归的单层逻辑什么的还是写不太清。。。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def sumOfLeftLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            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)  # 右子树上的左叶子之和
        sum = leftvalue + rightvalue
        return sum

代码随想录、代码随想录、代码随想录