算法随想第16天

平衡二叉树

  判断一个二叉树是否为平衡二叉树，递归的判断条件是当遍历至某个节点时，首先该节点对应的两个子树需要满足平衡条件(左右子树之间高度不超过1)，那么需要获取左右子树的高度，利用递归获取左右子树的高度是否为-1(因为左右子树其中一棵树为-1，那么两者之间的差值一定会超过1，即不满足平衡)，然后判断两者之差是否大于1，大于1即返回-1，不大于1则返回两个子树中的最大高度(为了与节点对应的另一节点判断是否平衡)

class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.get_height(root) != -1
    def get_height(self,node): 
        if not node:
            return 0
        leftheight = self.get_height(node.left)  # 左子树的高度(后序遍历)
        rightheight = self.get_height(node.right) # 右子树的高度(后序遍历)
        if leftheight == -1 or rightheight == -1 or abs(leftheight-rightheight) > 1: #左子树的所有子树满足平衡；右子树的所有子树满足平衡；左右子树之间满足平衡；否则返回-1
            return -1
        return 1 + max(leftheight,rightheight) # 该节点满足平衡则返回该节点对应的子树的最大高度，与对应的另一子树判断是否平衡

二叉树的所有路径

  该题用前序遍历记录路径，首先先将节点值append进path中，然后对该节点是否为叶子节点进行判断，遍历至叶子节点(即无左右节点时)将path放入result中表示一条完整路径。如果不是叶子节点则进行左右子节点的迭代，有子节点则进行迭代，需要将path与result传参进去，迭代一次后，需要将path最新的元素pop出来(回溯过程：将路径从子节点返回至节点，以便进行同层另外子节点的路径遍历)。

class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        result = []
        path = []
        path, result = self.traver(root,path,result)
        return result

    def traver(self,node,path,result):
        path.append(str(node.val))
        if not (node.left or node.right):
            result.append('->'.join(path))
            return path, result
        if node.left:
            path, result = self.traver(node.left,path,result)
            path.pop()
        if node.right:
            path, result = self.traver(node.right,path,result)
            path.pop()
        return path, result

左叶子之和

解法一（递归）

class Solution(object):
    def sumOfLeftLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """  
        if not root:
            return 0
        if not (root.left or root.right):  # 当前节点为叶子节点
            return 0 
        if root.left and not (root.left.left or root.left.right): #当前节点为叶子节点的上一节点   #左
            s_left = root.left.val
        else:
            s_left = self.sumOfLeftLeaves(root.left)
        s_right = self.sumOfLeftLeaves(root.right)   # 右
        s = s_left+s_right  #中
        return s

解法二（迭代–前序遍历）

class Solution(object):
    def sumOfLeftLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        stack = [root]
        s = 0
        while stack:
            cur = stack.pop()
            if cur.left and not (cur.left.left or cur.left.right):
                s += cur.left.val
            if cur.left:
                stack.append(cur.left)
            if cur.right:
                stack.append(cur.right)
        return s