二叉树的递归

最新推荐文章于 2024-05-27 23:16:40 发布

xytywh

最新推荐文章于 2024-05-27 23:16:40 发布

阅读量134

点赞数

分类专栏：数据结构与算法文章标签：二叉树递归

本文链接：https://blog.csdn.net/xiaohuihui1994/article/details/90647809

版权

数据结构与算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

这篇博客主要探讨了二叉树中两种类型的路径问题：1.从根节点到叶子节点的路径，涉及leetcode的112、113、129和257题；2.虽不从根节点开始，但保持连续的路径，如leetcode的437题。

摘要由CSDN通过智能技术生成

1.是从根节点到叶子结点

leetcode-112

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        #边界情况1是root为None
        if not root:
            return False
            
		#边界情况2是到达叶子结点
        if not root.left and not root.right:
            return root.val == sum
            
        # or用的很好，体会一下
        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)

leetcode-113

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: List[List[int]]
        """
        #边界情况1，root为None
        if not root:
            return []
            
        #边界情况2，到达叶子结点
        if not root.left and not root.right:
        
        	#如果叶子结点值等于sum，显然需要把叶子结点加到路径中
            if root.val == sum:
                return [[sum]]
                
            #如果叶子结点值不等于sum，返回一个空路径
            else:
                return []
                
        path = [[root.val] + path for path in self.pathSum(root.left, sum - root.val)]
        path += [[root.val] + path for path in self.pathSum(root.right, sum - root.val)]
        return path

leetcode-129

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def sumNumbers(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        # 正是由于题目说明每个结点都存放一个0-9的数字，才可以取每个路径，然后将str转为int类型
        # 否则不可以这么做
        paths = self.getpath(root)
        res = 0
        for path in paths:
            res += int(path)
        return res

   def getpath(self, root):
       if not root:
           return []
       if not root.left and not root.right:
           return [str(root.val)]
       treepaths = [str(root.val) + path for path in self.getpath(root.left)]
       treepaths += [str(root.val) + path for path in self.getpath(root.right)]
       return treepaths

leetcode-257

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        if not root:
            return []
        if not root.left and not root.right:
            return [str(root.val)]
        treepaths = [str(root.val) + '->' + path for path in self.binaryTreePaths(root.left)]
        treepaths += [str(root.val) + '->' + path for path in self.binaryTreePaths(root.right)]
        return treepaths

2.不需要从根节点到叶子结点，但也是一个连续的路径

leetcode-437

在这里插入图片描述

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: int
        """
        # 在以root为根节点的二叉树中，寻找和为sum的路径，返回这样的路径个数
        if not root:
            return 0
        # 1.包含root结点，且其和为sum的路径个数
        res = self.findpath(root, sum)
        # 2.不包含root结点，且和为sum的路径个数，有两种情况，分别是左右子树
        res += self.pathSum(root.left, sum)
        res += self.pathSum(root.right, sum)
        return res

    # 正确写法
    def findpath(self, node, num):
        # 在以node为根节点的二叉树中，寻找包含node的路径，和为sum，返回这样的路径个数
        if not node:
            return 0
        res = 0
        if node.val == num:
            res += 1
        res += self.findpath(node.left, num - node.val)
        res += self.findpath(node.right, num - node.val)
        return res

    # 错误写法
    def findpath(self, node, num):
        # 在以node为根节点的二叉树中，寻找包含node的路径，和为sum，返回这样的路径个数
        if not node:
            return 0
        # 这里当node.val==num时，不应该返回1，而只是代表找到了一条路径，当前node不一定是叶子结点
        # 所以还需要继续从当前结点往下进行寻找，所以上面的写法才是正确的
        if node.val == num:
            return 1
        res = self.findpath(node.left, num - node.val)
        res += self.findpath(node.right, num - node.val)
        return res