力扣刷题：二叉树相关（Python实现）

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

一、前序遍历

        1.1递归

    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def dfs(root):
            if not root:
                return []
            res.append(root.val)
            dfs(root.left)
            dfs(root.right)
        dfs(root)
        return res

        1.2迭代

    def preorderTraversal(self, root: TreeNode) -> List[int]:
        def preorder(root:TreeNode):
            if not root:
                return
            res.append(root.val)
            preorder(root.left)
            preorder(root.right)
        res=list()
        preorder(root)
        return res

        1.3MORRIS

二、中序遍历

        2.1递归

    def inorderTraversal(self, root: TreeNode) -> List[int]:
        def inorder(root:TreeNode):
            if not root:
                return
            inorder(root.left)
            res.append(root.val)
            inorder(root.right)
        res=list()
        inorder(root)
        return res

        2.2迭代

    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        res, stack = [], []
        while root or stack:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop() 
            res.append(root.val)
            root = root.right
        return res

        2.3MORRIS

三、后序遍历

        略

四、层序遍历

        4.1广度优先

    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
            
        queue = [root]
        res = []
        while queue:
            length = len(queue) #每层节点数
            sub_list = []
            for i in range(length):
                node = queue.pop(0) #出队
                sub_list.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(sub_list)
        return res

五、二叉树最大深度

    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        l = self.maxDepth(root.left)
        r = self.maxDepth(root.right)
        return max(l,r) + 1

六、对称二叉树

    def isSymmetric(self, root: TreeNode) -> bool:
        if not root :return True
        def judge(left,right):
            if not left and not right:
                return True
            if left and right and left.val==right.val:
                return judge(left.left,right.right) and judge(left.right,right.left)
            return False
        
        return judge(root,root)

七、路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。叶子节点 是指没有子节点的节点。

    def hasPathSum(self, root:TreeNode, targetSum: int) -> bool:
        if not root:
            return False
        res=targetSum-root.val
        if (root.left==None and root.right==None) and res==0:
            return True
        else:
            return self.hasPathSum(root.left,res) or self.hasPathSum(root.right,res)

剑指 Offer 26. 树的子结构

class Solution:
    def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:
        def recur(A,B):
            if not B:return True #B遍历完毕
            if not A or A.val!=B.val: return False #A遍历完毕或值不相等
            #进入这一步的前提是当前A和B的结点值相等
            return recur(A.left,B.left) and recur(A.right,B.right)
    #A和B存在，且 （A和B完全相等 或 A从根节点（左/右）分支开始的某一节点开始与B相等）
    return bool(A and B) and (recur(A,B) or self.isSubStructure(A.left,B) or self.isSubStructrue(A.right,B))

剑指 Offer 27. 二叉树的镜像

27.1栈

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

27.2递归

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root: return 
        temp=root.left    #temp保存当前节点的左节点

        root.left=self.mirrorTree(root.right)
        #持续递归直到没有当前节点没有右节点，将当前节点返回到上一层递归的这一式子，即上一节点
        #的.left等于这最后一个右节点，完成了交换
        
        root.right=self.mirrorTree(temp)
        #此时temp保存的是当前节点的左节点，若为完全二叉树，接上一注释，此时已经返回到了上一层递归 
        #此时temp也没有后续的左右节点，修改当前节点的右节点为temp，完成了最下层的镜像交换       
        return root

剑指 Offer 28. 对称的二叉树

28.1左右栈

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root: return True
        stack_left,stack_right=[],[]
        if root.left: stack_left.append(root.left)
        if root.right: stack_right.append(root.right)
        while stack_left and stack_right:
            left_node,right_node=stack_left.pop(),stack_right.pop()
            if left_node.val==right_node.val:
                if left_node.left and right_node.right:
                    stack_left.append(left_node.left)
                    stack_right.append(right_node.right)
                elif left_node.left or right_node.right: return False
                if left_node.right and right_node.left:
                    stack_left.append(left_node.right)
                    stack_right.append(right_node.left)
                elif left_node.right or right_node.left: return False                    
            else:return False
        if stack_left or stack_right:
            return False
        return True

未完

二叉树 - LeetBook - 力扣（LeetCode）全球极客挚爱的技术成长平台 (leetcode-cn.com)https://leetcode-cn.com/leetbook/detail/data-structure-binary-tree/

图解算法数据结构 - LeetBook - 力扣（LeetCode）全球极客挚爱的技术成长平台 (leetcode-cn.com)https://leetcode-cn.com/leetbook/detail/illustration-of-algorithm/