二叉树相关算法题总结-python实现

二叉树问题一般都是采用递归的思路解答

目录

题目一：平衡二叉树

题目二 ：判断二叉树是否对称

题目三：二叉树的镜像

题目四：合并二叉树

题目五：二叉树的层次遍历

题目六：二叉树根节点到叶子节点和为指定值的路径

题目七：二叉树的之字形层序遍历

题目八：二叉树根节点到叶子节点的所有路径和

​

题目九：二叉树的中序遍历

---

---

题目一：平衡二叉树

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

详解：针对一个节点，需要做的事情是，拿到该节点左子树的深度和右子树的深度

代码实现：

class Solution:
    def IsBalanced_Solution(self, pRoot):
        # write code here
        if not pRoot:
            return True
                     
        def get_depth(root):
            if not root:
                return 0
            else:
                return 1 + max(get_depth(root.left),get_depth(root.right))
        return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right) and abs(get_depth(pRoot.left)-get_depth(pRoot.right))<=1

错误解法：

错误解析：该错误在于仅判断根节点的左子树深度与右子树的深度，并没有考虑到左子树也需要是一个平衡二叉树

class Solution:
    def IsBalanced_Solution(self, pRoot):
        # write code here
        def dfs(root):
            if root is None:
                return 0
            return 1+max(dfs(root.left),dfs(root.right))
        if pRoot is None:
            return True
        if abs(dfs(pRoot.left)-dfs(pRoot.right))>1:
            return False
        else:
            return True
        

题目二 ：判断二叉树是否对称

给定一棵二叉树，判断其是否是自身的镜像（即：是否对称）

代码示例：

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

#
# 
# @param root TreeNode类 
# @return bool布尔型
#
class Solution:
    def isSymmetric(self , root ):
        # write code here
        def is_equal(left,right):
            if not left and not right:
                return True
            if left and right and left.val==right.val:
                return is_equal(left.left, right.right) and is_equal(left.right, right.left)
        if not root:
            return True
        return is_equal(root.left, root.right)
                

题目三：二叉树的镜像

操作给定的二叉树，将其变换为源二叉树的镜像。

详解：其实就是将左子树和右子树递归的交换位置

代码示例：

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param pRoot TreeNode类 
# @return TreeNode类
#
class Solution:
    def Mirror(self , pRoot ):
        # write code here
        if not pRoot:
            return None
        cur = pRoot 
        temp = cur.left
        cur.left = cur.right
        cur.right = temp
        self.Mirror(cur.left)
        self.Mirror(cur.right)
        return pRoot

题目四：合并二叉树

已知两颗二叉树，将它们合并成一颗二叉树。合并规则是：都存在的结点，就将结点值加起来，否则空的位置就由另一个树的结点来代替

代码详解：

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

#
# 
# @param t1 TreeNode类 
# @param t2 TreeNode类 
# @return TreeNode类
#
class Solution:
    def mergeTrees(self , t1 , t2 ):
        # write code here
        if not t1 and not t2:return
        if not t1: return t2
        if not t2: return t1
        t1.val+=t2.val
        t1.left = self.mergeTrees(t1.left, t2.left)
        t1.right = self.mergeTrees(t1.right, t2.right)
        return t1

题目五：二叉树的层次遍历

采用广度遍历思想，先声明一个树结构，

第一步：先将根节点压入队列中：3压入队列，q=[3]

第二步：判断队列的长度，长度就是该树本层的节点个数，遍历这个长度，构建本层的数组，从队列中每出一个节点，再将该节点的左右子树压入队列中

比如：目前队列的长度是1，则构建数组temp=[3]，3的左右子树分别压入队列中，q=[9,10]

第二次遍历，队列的长度是2，则遍历两个来构建temp，9出队列，9的左右子树进队列，没有则跳过，10出队列，将10的左右子树压入队列，此时temp=[9,10]，本层已经结束

进入下一层

总结：先判

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

#
# 
# @param root TreeNode类 
# @return int整型二维数组
#
class Solution:
    def levelOrder(self , root ):
        # write code here
        res = []
        if not root:
            return res
        q = []
        q.insert(0,root)
        while len(q)>0:
            temp = []
            n = len(q)
            for i in range(n):
                node = q.pop()
                temp.append(node.val)
                if node.left :
                    q.insert(0,node.left)
                if node.right:
                    q.insert(0,node.right)
            res.append(temp)
        return res
        

题目六：二叉树根节点到叶子节点和为指定值的路径

题解：

path存当前路径

代码：

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

#
# 
# @param root TreeNode类 
# @param sum int整型 
# @return int整型二维数组
#
class Solution:
    def __init__(self):
        self.res = []
        self.path = []
         
    def pathSum(self , root , num ):
        # write code here
        if root is None:
            return []
         
        self.path.append(root.val)
        if root.left is None and root.right is None and sum(self.path) == num:
            self.res.append(self.path[:])
        self.pathSum(root.left, num)
        self.pathSum(root.right, num)
        self.path.pop()
        return self.res

题目七：二叉树的之字形层序遍历

与正常遍历的唯一区别在于记录一下层级，奇数层级利用python的append操作，从后追加，偶数层级，利用list的insert，从前往后插入

广度遍历依然利用队列结构，每次出一个元素时，将该元素的左孩子和右孩子依次入队列

代码：

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

#
# 
# @param root TreeNode类 
# @return int整型二维数组
#
class Solution:
    def zigzagLevelOrder(self , root ):
        # write code here
        if not root:return[]
#       模拟队列
        q = []
        res = []
#         记录层级
        depth = 1 
        q.append(root)
        while q:
            temp =[]
#             当前层级的长度
            q_len = len(q)
            for i in range(q_len):
                current = q.pop(0)
                if current.left:
                    q.append(current.left)
                if current.right:
                    q.append(current.right)
                if depth%2==0:
                    temp.insert(0,current.val)
                else:
                    temp.append(current.val)
            depth+=1
            res.append(temp)
        return res
        

题目八：二叉树根节点到叶子节点的所有路径和

题解：求所有路径和其实是当前节点+(左子树和右子树)

利用深度遍历，

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

#
# 
# @param root TreeNode类 
# @return int整型
#
class Solution:
    def sumNumbers(self , root ):
        # write code here
        total =0 
        def dfs(root,total):
            if not root:
                return 0
            total=total*10+root.val
#             注意条件，左子树和右子树都为空时
            if not root.left and not root.right:
                return total
            return dfs(root.left,total)+dfs(root.right,total)
        return dfs(root,total)
                

题目九：二叉树的中序遍历

前序，中序和后续都可以用该方法

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型一维数组
#
class Solution:
    def inorderTraversal(self , root ):
        # write code here
        res = []
        def dfs(root):
            if not root:
                return
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
        dfs(root)
        return res