python | 二叉树的代码：层次遍历、最大深度、路径总和、相同的树

最新推荐文章于 2024-02-16 14:30:00 发布

大虎牙

最新推荐文章于 2024-02-16 14:30:00 发布

阅读量353

点赞数

CC 4.0 BY-SA版权

分类专栏： # Python语言 # 数据结构 | 刷题 | 面试文章标签：二叉树

本文链接：https://blog.csdn.net/qq_34170700/article/details/105018155

数据结构 | 刷题 | 面试同时被 2 个专栏收录

69 篇文章

订阅专栏

Python语言

44 篇文章

订阅专栏

本文详细介绍了如何使用Python进行二叉树的层次遍历、求解最大深度、判断是否为平衡二叉树、计算路径总和以及检查两棵树是否相同的操作。通过示例代码展示了具体实现过程。

102. 二叉树的层次遍历

给定一个二叉树，返回其按层次遍历的节点值。
(即逐层地，从左到右访问所有节点)。

例如:

给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

代码

# 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 levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        ret = [[root.val]]
        level = [root]
        
        while level:
            values = []
            nodes = []
            for it in level:
                if it.left:
                    values.append(it.left.val)
                    nodes.append(it.left)
                if it.right:
                    values.append(it.right.val)
                    nodes.append(it.right)
            if values:
                ret.append(values)
            level = nodes
        return ret

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明:

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

示例：

给定二叉树 [3,9,20,null,null,15,7]，返回它的最大深度 3 。

代码

# 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 maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
    
        if not root:
            return 0
        return 1+max(self.maxDepth(root.left), self.maxDepth(root.right))

110. 平衡二叉树

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

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

返回 false。

代码

# 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 isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        
        
        
        def depth(root):
            if not root:
                return 0
            return 1 + max(depth(root.left),depth(root.right))
        
        if abs(depth(root.left) - depth(root.right)) > 1:
            return False
        
        return self.isBalanced(root.left) and self.isBalanced(root.right)

面试题 17.12. BiNode

二叉树数据结构TreeNode可用来表示单向链表（其中left置空，right为下一个链表节点）。

实现一个方法，把二叉搜索树转换为单向链表，要求值的顺序保持不变，转换操作应是原址的，也就是在原始的二叉搜索树上直接修改。
返回转换后的单向链表的头节点。

注意：本题相对原题稍作改动

示例：

输入： [4,2,5,1,3,null,6,0]
输出： [0,null,1,null,2,null,3,null,4,null,5,null,6]

# 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 convertBiNode(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return None
        head,tail = self.travel(root)
        return head

    def travel(self,root):
        head,tail = root,root
        if root.left:
            left_head,left_tail = self.travel(root.left)
            head = left_head
            left_tail.right = root
        if root.right:
            right_head,right_tail = self.travel(root.right)
            tail = right_tail
            root.right = right_head
        root.left = None
        return head,tail

112. 路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明:

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

示例:

给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

# 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
        """
        if not root: 
            return False
        if not root.left and not root.right and sum - root.val == 0:
            return True
            
        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)

100 相同的树

给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:       1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

输出: true

示例 2:

输入:      1          1
          /           \
         2             2

        [1,2],     [1,null,2]

输出: false

示例 3:

输入:       1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

输出: false

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isSameTree(self, p, q):
        """
        :type p: TreeNode
        :type q: TreeNode
        :rtype: bool
        """
        if not p and q:
            return False
        elif p and not q:
            return False
        elif not p and not q:
            return True
        elif p and q and p.val != q.val:
            return False
        else:
            return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)