代码随想录Day17

110.平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

递归法

class Solution:
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if self.get_height(root) !=-1:
            return True
        else:
            return False  
    def get_height(self,root):
        if not root:
            return 0
        if (left_height:=self.get_height(root.left))==-1:
            return -1
        if (right_height:=self.get_height(root.right))==-1:
            return -1
        if abs(right_height-left_height)>1:
            return -1
        else:
            return 1 + max(left_height, right_height)

递归法精简版

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        return self.get_hight(root) != -1
    def get_hight(self, node):
        if not node:
            return 0
        left = self.get_hight(node.left)
        right = self.get_hight(node.right)
        if left == -1 or right == -1 or abs(left - right) > 1:
            return -1
        return max(left, right) + 1

迭代法先过了二刷再说

257. 二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径

递归法加回溯

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

递归法加隐形回溯

写法一

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

CHATGPT答：

“回溯” 是一种算法范式，而 “隐形回溯” 是一种回溯算法的变体。它们之间的主要区别在于算法的实现和执行方式。下面我将解释它们的区别：

回溯（Backtracking）：

回溯是一种递归算法，通常用于解决组合问题、排列问题、子集问题等组合优化问题。
在回溯算法中，我们从一个可能的解决方案开始，然后尝试不同的选择，直到找到一个有效的解决方案或者确定无解。
如果在尝试一些选择后，发现无法找到有效解决方案，就会回溯到前一个决策点，尝试其他选择，直到所有可能的选择都被尝试过。
隐形回溯（Implicit Backtracking）：

隐形回溯是一种特殊的回溯算法，通常用于解决搜索问题，其中没有明显的决策点和选择，而是通过递归遍历搜索空间来找到解决方案。
隐形回溯不需要明确的“回溯”步骤，因为在搜索树的遍历中会自动发生回溯。
隐形回溯常常用于解决图搜索、迷宫问题、拓扑排序等问题，其中不需要明确的决策点，而是通过深度优先搜索来遍历搜索空间。
总的来说，回溯是一种更一般的算法范式，可以用于解决各种组合问题，它强调了在每个决策点的选择和回溯。而隐形回溯是回溯的一种特殊形式，用于处理没有明显决策点的搜索问题，它侧重于搜索空间的深度遍历。随着具体问题的不同，你可以选择使用普通的回溯算法或隐形回溯来解决问题。

404.左叶子之和

递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。

递归三部曲：

1.确定递归函数的参数和返回值
判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int

使用题目中给出的函数就可以了。

2.确定终止条件
如果遍历到空节点，那么左叶子值一定是0

class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        if root is None:
            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)
        sum_val=leftvalue+rightvalue
        return sum_val