代码随想录算法训练营第16天 | 二叉树03

110.平衡二叉树
https://leetcode.cn/problems/balanced-binary-tree/submissions/540479822/
110.平衡二叉树代码随想录
https://programmercarl.com/0110.平衡二叉树.html
257. 二叉树的所有路径
https://leetcode.cn/problems/binary-tree-paths/submissions/540487197/
257. 二叉树的所有路径代码随想录
https://programmercarl.com/0257.二叉树的所有路径.html#算法公开课
404.左叶子之和 （优先掌握递归）https://leetcode.cn/problems/sum-of-left-leaves/submissions/
404.左叶子之和 （优先掌握递归）代码随行录
https://programmercarl.com/0404.左叶子之和.html
222.完全二叉树的节点个数（优先掌握递归）
https://leetcode.cn/problems/count-complete-tree-nodes/submissions/540520637/
完全二叉树节点个数 代码随想录
https://programmercarl.com/0222.完全二叉树的节点个数.html

110. 平衡二叉树

题目

给定一个二叉树，判断它是否是 平衡二叉树

题解重点：

• 递归法：如果发现某一层不平衡 直接将-1传回去 这样传递，迭代到最终结果；
• 迭代法：先利用迭代法栈求高度；再判断是否平衡（可以直接用字典存储）

题解代码

递归法

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        return self.getdeepth(root)!=-1

    def getdeepth(self,root):
        if not root:
            return 0
        right = self.getdeepth(root.right)
        left = self.getdeepth(root.left)
        if right==-1:
            return -1
        if left==-1:
            return -1
        if abs(right-left)>1:
            return -1
        else:
            return 1+max(self.getdeepth(root.right),self.getdeepth(root.left))

迭代法

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        st = [root]
        while st:
            node = st.pop()
            if node:
                st.append(node)
                st.append(None)
                if node.right:
                    st.append(node.right)
                if node.left:
                    st.append(node.left)
            else:
                curr =  st.pop()
                right = self.getdeepth(curr.right)
                left = self.getdeepth(curr.left)
                if abs(right-left)>1:
                    return False
        return True

    def getdeepth(self,root):
        if not root:
            return 0
        st = [root]
        dep = 0
        res = 0
        while st:
            node = st.pop()
            if node:
                st.append(node)
                st.append(None)
                dep = dep+1
                if node.right:
                    st.append(node.right)
                if node.left:
                    st.append(node.left)
            else:
                curr = st.pop()
                dep = dep-1
            res = max(res,dep)
        return res

257. 二叉树的所有路径

题目

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

题解

• 递归法：传递 trans 函数即可 trans 函数首先增加节点，然后判断左右子树
• 迭代法：path回溯；添加一个path_st 和 node_st作用一样

题解代码

递归法

class Solution:
    def trans(self,curr,path,res):
        path.append(curr.val)
        if not curr.right and not curr.left:
            spath = '->'.join(map(str,path))
            res.append(spath)
            return
        if curr.left:
            self.trans(curr.left,path,res)
            path.pop()
        if curr.right:
            self.trans(curr.right,path,res)
            path.pop()

    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        res = []
        path = []
        if not root:
            return res
        self.trans(root,path,res)
        return res

class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        if not root:
            return []
        st = [root]
        path = [str(root.val)]
        res = []
        while st:
            node = st.pop()
            path_i = path.pop()
            if node:
                if node.right:
                    st.append(node.right)
                    path.append(path_i+'->'+str(node.right.val))
                if node.left:
                    st.append(node.left)
                    path.append(path_i+'->'+str(node.left.val))
                st.append(node)
                path.append(path_i)
                st.append(None)
            else:
                curr = st.pop()
                if not curr.right and not curr.left:
                    res.append(path_i)
        return res

左叶子之和

题目

给定二叉树的根节点 root ，返回所有左叶子之和。

题解

• 递归法：停止逻辑：左叶子节点：直接返回左叶子节点；root的左子树的叶子节点+root的右子树的左叶子节点
• 迭代法：遍历到左叶子节点求和即可

题解代码

递归法

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

迭代法

class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        res = 0
        if not root:
            return res
        stack = [root]
        while stack:
            node = stack.pop()
            if node:
                stack.append(node)
                stack.append(None)
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                if node.left and not node.left.right and not node.left.left:
                    res = res+node.left.val
        return res

222.完全二叉树的节点个数

题目

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

题解重点

• 完全二叉树个数：2**height-1
• 2<<0和2**\1等价

题解代码

递归法

class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        deep = 0
        left = root.left
        right = root.right
        while left and right:
            left = left.left
            right = right.right
            deep = deep+1
        if not left and not right:
            return (2<<deep)-1
        return 1+self.countNodes(root.left)+self.countNodes(root.right)