二叉树的几道相似简单递归题

cnhwl

已于 2022-04-25 16:18:40 修改

阅读量2.1k

点赞数 1

分类专栏： Python与Leetcode刷题文章标签： 1024程序员节 leetcode 算法二叉树递归法

于 2021-10-24 18:25:21 首次发布

本文链接：https://blog.csdn.net/cnhwl/article/details/120937750

版权

Python与Leetcode刷题专栏收录该内容

44 篇文章 5 订阅

订阅专栏

二叉树中递归的思想，在这本Leetbook中讲的很细了，这里不展开。下面是几道例题：

226. 翻转二叉树（剑指 Offer 27. 二叉树的镜像）

递归法前序遍历：

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return
        root.left, root.right = root.right, root.left    
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

迭代法前序遍历：

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return root
        stack = []
        stack.append(root)
        while stack:
            node = stack.pop()
            if node:
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
                stack.append(node)
                stack.append(None)
            else:
                node = stack.pop()
                node.left, node.right = node.right, node.left
        return root

递归法中序遍历（伪）：

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return
        self.invertTree(root.left)
        root.left, root.right = root.right, root.left    
        self.invertTree(root.left)
        return root

迭代法中序遍历：

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return root
        stack = []
        stack.append(root)
        while stack:
            node = stack.pop()
            if node:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                node.left, node.right = node.right, node.left
        return root

递归法后序遍历：

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return
        left = self.invertTree(root.left)
        right = self.invertTree(root.right)
        root.left, root.right = right, left
        return root

迭代法后序遍历：

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return root
        stack = []
        stack.append(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()
                node.left, node.right = node.right, node.left
        return root

在遍历的过程中，把记录节点值这个操作改成交换左右子节点即可，前中后序遍历都是可以的，递归法和迭代法都行。唯一要注意的就是中序遍历，用递归法是左根左，因为使用递归的中序遍历，某些节点的左右孩子会翻转两次。甚至，层序遍历也是可以的，可以看我的这篇文章。

100. 相同的树

class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if (not p) and (not q):
            return True
        elif (not p) or (not q):
            return False
        elif p.val != q.val:
            return False
        else:
            return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

判断两个二叉树是否相同，思路如下：两个二叉树是否同时为空？是否一个为空而另一个不为空？他们的根节点值是否相同？最后是递归的判断，他们的左右子树是否都相同？

101. 对称二叉树（剑指 Offer 28. 对称的二叉树）

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        return self.check(root, root)

    def check(self, p: TreeNode, q: TreeNode) -> bool:
        if (not p) and (not q):
            return True
        elif (not p) or (not q):
            return False
        elif p.val != q.val:
            return False
        else:
            return self.check(p.left, q.right) and self.check(p.right, q.left)

判断一个二叉树是否为对称二叉树，可以转化为判断这个树和自己的镜像树是否相同。关键在于用 self.check(root, root) 构造出两个树，然后以相反方向进行递归和判断。

迭代写法的话使用的是队列，用栈或者数组等其他的容器都行，关键是把节点放入容器的顺序不能错，然后每次取两个左右对应位置的节点出来做比较，如下：

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left)
        queue.append(root.right)
        while queue:
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if (not leftNode) and (not rightNode):
                continue
            elif (not leftNode) or (not rightNode):
                return False
            elif leftNode.val != rightNode.val:
                return False
            else:
                queue.append(leftNode.left)
                queue.append(rightNode.right)
                queue.append(leftNode.right)
                queue.append(rightNode.left)
        return True

617. 合并二叉树

class Solution:
    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        if not root1 and not root2:
            return None
        if not root1:
            return root2
        if not root2:
            return root1
        new_root = TreeNode(root1.val + root2.val)  # 新建节点
        new_root.left = self.mergeTrees(root1.left, root2.left)
        new_root.right = self.mergeTrees(root1.right, root2.right)
        return new_root

两个二叉树一起从根节点开始向下递归，如果其中一个二叉树的节点为空，则合并后的节点就是另一个二叉树的节点。合并后的二叉树每次都要新建节点，然后左右子树用递归得到。优化的写法是不新建节点，直接用其中一个二叉树的节点，只需要把另一个二叉树的节点值加过去即可。

class Solution:
    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        if not root1 and not root2:
            return None
        if not root1:
            return root2
        if not root2:
            return root1
        root1.val += root2.val  # 用旧节点
        root1.left = self.mergeTrees(root1.left, root2.left)
        root1.right = self.mergeTrees(root1.right, root2.right)
        return root1

104. 二叉树的最大深度

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        left_depth = self.maxDepth(root.left)
        right_depth = self.maxDepth(root.right)
        return max(left_depth, right_depth) + 1

自底向上的递归，在Leetbook中有详细介绍，简单来说：如果我们知道一个根节点，以其左子节点为根的最大深度为 left_depth 和以其右子节点为根的最大深度为 right_depth ，我们就可以选择它们之间的最大值，再加上1来获得根节点所在的子树的最大深度。

543. 二叉树的直径

class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        self.ans = 1
        
        def depth(node: TreeNode):
            if not node:
                return 0
            left_depth = depth(node.left)
            right_depth = depth(node.right)
            # 此节点作为根节点的最大深度是否为众节点中最大，是则更新ans
            self.ans = max(self.ans, left_depth + right_depth + 1)
            return max(left_depth, right_depth) + 1

        depth(root)
        return self.ans - 1

虽然题目说明了直径（最大的两节点间路径）不一定经过根节点，但是归根到底，两节点间路径必然会有个根节点，目标就是找到把树中所有节点都作为根节点时，各自求出最大深度（上一题思路），然后在这些最大深度中找到最大的作为直径 ans。

563. 二叉树的坡度

class Solution:
    def findTilt(self, root: TreeNode) -> int:
        self.ans = 0

        def val_sum(node: TreeNode):
            if not node:
                return 0
            left_sum = val_sum(node.left)
            right_sum = val_sum(node.right)
            tilt = abs(left_sum - right_sum)
            self.ans += tilt
            return left_sum + right_sum + node.val
        
        val_sum(root)
        return self.ans

本题与最大深度类似，区别在于是记录深度之差的绝对值（坡度），然后递归返回左右子树和自身值之和。

112. 路径总和

class Solution:
    def hasPathSum(self, root: TreeNode, targetSum: int) -> bool:
        if not root: # 非节点
            return False
        if not root.left and not root.right:  # 叶子节点
            return targetSum == root.val
        return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(root.right, targetSum - root.val)

思路是如果子树的和等于 targetSum 减去当前节点的值，则存在路径。所以终止条件为非节点则返回 False，为叶子节点则返回 targetSum == 当前节点的值，函数调用是子节点和减去当前节点值后的 targetSum 。

113. 路径总和 II（剑指 Offer 34. 二叉树中和为某一值的路径）

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        ans = []
        path = []
        
        def dfs(root: TreeNode, targetSum: int):
            if not root:
                return
            path.append(root.val)
            targetSum -= root.val
            if not root.left and not root.right and targetSum == 0:
                ans.append(path.copy())
            dfs(root.left, targetSum)
            dfs(root.right, targetSum)
            path.pop()
        
        dfs(root, targetSum)
        return ans

这题不是求有没有路径，而是要把路径都找出来，答案放在列表 ans 里。同样还是递归地深度遍历，用一个 path 列表记录路径，如果是叶节点且和数符合条件，就往 ans 里面加入路径 path，否则就遍历左子树和右子树，记得递归的最后要把 path 进行弹出，然后注意往 ans 里面加入的是 path 的浅拷贝，可以写成 path.copy() 或者 path[:]

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

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if not root:
            return 0
        left = root.left
        right = root.right
        # 深度初始化为 0，是因为位运算中 2 << 0 == 2，2 << 1 == 4
        leftHeight = 0
        rightHeight = 0
        # 求左子树深度
        while left:
            left = left.left
            leftHeight += 1
        # 求右子树深度
        while right:
            right = right.right
            rightHeight += 1
        # 若为满二叉树，则节点数为 2 的 leftHeight 次方，用位运算求
        if leftHeight == rightHeight:
            return (2 << leftHeight) - 1
        return self.countNodes(root.left) + self.countNodes(root.right) + 1

这题用常规的前中后序遍历或者层序遍历都能做，但是这样就没利用到完全二叉树的性质了。完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

优化点就是用位运算代替指数运算。

236. 二叉树的最近公共祖先

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':

        def dfs(root: 'TreeNode', p: 'TreeNode', q: 'TreeNode'):
            # 如果当前节点为空，则说明 p、q 不在 node 的子树中，不可能为公共祖先，直接返回 None
            if not root:
                return None
            
            # 如果当前节点 root 等于 p 或者 q，那么 root 就是 p、q 的最近公共祖先，直接返回 root
            if root == p or root == q:
                return root
            
            # 递归遍历左子树、右子树，并判断左右子树结果
            node_left = dfs(root.left, p, q)
            node_right = dfs(root.right, p, q)
            # 如果左右子树都不为空，则说明 p、q 在当前根节点的两侧，当前根节点就是他们的最近公共祖先
            if node_left and node_right:
                return root
            elif node_left:
            	return node_left:
           	else:
           		return node_right
        
        ans = dfs(root, p, q)
        return ans

简单概括，就是基于后序遍历，从下往上，在找到 p 或者 q 的时候就返回。这样当 p 和 q 在两边时，就会返回最近公共祖先；当 p 和 q 在同一条路径上时，就会返回两者中作为祖先的那个。

cnhwl

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二叉树的几道相似简单递归题

二叉树中递归的思想，在这本Leetbook中讲的很细了，这里不展开。下面是几道例题：100. 相同的树class Solution: def isSameTree(self, p: TreeNode, q: TreeNode) -> bool: if (not p) and (not q): return True elif (not p) or (not q): return False el
复制链接

扫一扫