leetcode 第十六天 2024.8.1

1. 完全二叉树的节点个数：
 题目链接: 222. 完全二叉树的节点个数 - 力扣（LeetCode）
应用条件：迭代，递归

难点：

本题较为简单，迭代法和递归法都可以实现，迭代法很简单，递归总是想不到递归对象导致写不出递归。

个人错误：

还是不能熟练写出递归法。

思路：

如下

迭代法：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        que = deque()
        que.append(root)
        res = 0
        while que:
            node = que.popleft()
            res += 1
            if node.left:
                que.append(node.left)
            if node.right:
                que.append(node.right)
        return res

递归法：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        sc = self.getcount(root)
        return sc
    def getcount(self,cur):
        if not cur:
            return 0
        lefc = self.getcount(cur.left)
        rigc = self.getcount(cur.right)
        summ = lefc + rigc +1
        return summ

2. 平衡二叉树：
 题目链接: ​​​​​​​110. 平衡二叉树 - 力扣（LeetCode）
应用条件：深度遍历，递归

难点：

本题如果使用迭代法的话会非常困难，很难考虑到所有情况。所以掌握递归法在这道题中尤为重要，但递归法要注意一点，在递归的过程中，计算每个节点的时候，helef = self.hei(cur.left) 而不能= self.hei(cur.left)+1。 要在判断完helef == -1 or herig == -1 or abs(helef - herig) >= 2后再取heih = max(helef,herig) +1。如果提前+1的话，会导致原先不平衡的节点本身是-1但再+1后变成0导致这个节点的不平衡判断不出来。

个人错误：

还是不能熟练写出递归法。

思路：

如下

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        if self.hei(root) == -1:
            return False
        else:
            return True

    def hei(self, cur):
        heih = 0
        if cur == None:
            return heih
        
        helef = self.hei(cur.left)
        herig = self.hei(cur.right)
        if helef == -1 or herig == -1 or abs(helef - herig) >= 2:
            return -1
        else:
            heih = max(helef,herig) +1
            return heih

 3. 二叉树的所有路径：
 题目链接: ​​​​​​​257. 二叉树的所有路径 - 力扣（LeetCode）
应用条件：迭代，递归

难点：

迭代：

迭代法相对于递归对思维的要求没那么高，迭代法的难点在于，在循环开始之前我们需要一个pathstr来记录我们每个节点所对应的路径，再一个节点一个节点的遍历下去的时候，我们需要有一个path（pathstr的最后一项对应cur是取自que的最后一项，cur和path是一一对应的）path再把cur这个节点更新到path上，当遇到叶子节点的时候，将记录的当前path加入到res里。遍历所有节点所有路径后返回res

递归：

递归法需要用到回溯，很不好写。因为我们在遍历到叶子节点的时候需要返回上一节点从而再判断有没有新的路径，所以再每次对cur.left 和cur.right递归后要对path进行pop（）操作。

个人错误：

还是不能熟练写出递归法。

思路：

迭代

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        if not root:
            return []
        que = deque()
        res =[]
        que.append(root)
        pathstr = []
        pathstr.append(str(root.val))
        while que:
            cur = que.pop()
            path = pathstr.pop()
            if not cur.left and not cur.right:
                res.append(path)
            if cur.left:
                que.append(cur.left)
                pathstr.append(path+"->"+str(cur.left.val))
            if cur.right:
                que.append(cur.right)
                pathstr.append(path+"->"+str(cur.right.val))
        return res

递归：

class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        result = []
        path = []
        if not root:
            return result
        self.trav(root, path, result)
        return result

    def trav(self,cur,path,res):
        path.append(cur.val)
        if cur.left == None and cur.right == None:
            sPath = '->'.join(map(str, path))
            res.append(sPath)
            return
        if cur.left:
            self.trav(cur.left,path,res)
            path.pop()
        if cur.right:
            self.trav(cur.right,path,res)
            path.pop()