二叉树学习

睿思佳

已于 2023-06-03 23:22:45 修改

阅读量60

点赞数

分类专栏： leetcode 文章标签：学习 python 算法

于 2023-05-29 23:25:08 首次发布

本文链接：https://blog.csdn.net/qq_38256519/article/details/130938761

版权

leetcode 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

解题思路

二叉树解题的思维模式分两类：

1、是否可以通过遍历一遍二叉树得到答案？如果可以，用一个 traverse 函数配合外部变量来实现，这叫「遍历」的思维模式。

2、是否可以定义一个递归函数，通过子问题（子树）的答案推导出原问题的答案？如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值，这叫「分解问题」的思维模式。

无论使用哪种思维模式，你都需要思考：
如果单独抽出一个二叉树节点，它需要做什么事情？需要在什么时候（前/中/后序位置）做？其他的节点不用你操心，递归函数会帮你在所有节点上执行相同的操作。

二叉树中用遍历思路解题时函数签名一般是 void traverse(…)，没有返回值，靠更新外部变量来计算结果，而用分解问题思路解题时函数名根据该函数具体功能而定，而且一般会有返回值，返回值是子问题的计算结果。

104. 二叉树的最大深度

104. 二叉树的最大深度
遍历方式

# 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
class Solution:
    def __init__(self):
        self.ans = 0
        self.depth = 0

    def maxDepth(self, root: Optional[TreeNode]) -> int:
        self.traverse(root)
        return self.ans
    
    def traverse(self, root:Optional[TreeNode]):
        if not root:
            return 
        self.depth += 1
        self.ans = max(self.ans, self.depth)
        self.traverse(root.left)
        self.traverse(root.right)
        self.depth -= 1

分解方式

# 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
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        left_max = self.maxDepth(root.left)
        right_max = self.maxDepth(root.right)
        return max(left_max, right_max) + 1

226. 翻转二叉树

226. 翻转二叉树
遍历方式

# 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
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        self.traceverse(root)
        return root

    def traceverse(self, root: Optional[TreeNode]):
        if not root:
            return
        root.left, root.right = root.right, root.left
        self.traceverse(root.left)
        self.traceverse(root.right)

分解方式

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

116. 填充每个节点的下一个右侧节点指针

import collections 

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        
        if not root:
            return root
        
        # 初始化队列同时将第一层节点加入队列中，即根节点
        Q = collections.deque([root])
        
        # 外层的 while 循环迭代的是层数
        while Q:
            
            # 记录当前队列大小
            size = len(Q)
            
            # 遍历这一层的所有节点
            for i in range(size):
                
                # 从队首取出元素
                node = Q.popleft()
                
                # 连接
                if i < size - 1:
                    node.next = Q[0]
                
                # 拓展下一层节点
                if node.left:
                    Q.append(node.left)
                if node.right:
                    Q.append(node.right)
        
        # 返回根节点
        return root

114. 二叉树展开为链表

114. 二叉树展开为链表
分解方式

# 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
class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        # base case
        if not root:
            return

        # 利用定义，把左右子树拉平
        self.flatten(root.left)
        self.flatten(root.right)

        # 后序遍历位置
        # 1、左右子树已经被拉平成一条链表
        left = root.left
        right = root.right

        # 2、将左子树作为右子树
        root.left = None
        root.right = left

        # 3、将原先的右子树接到当前右子树的末端
        p = root
        while p.right:
            p = p.right
        p.right = right

1110. 删点成林

1110. 删点成林
本题的难点在于返回根节点，并且还要修改二叉树
分解方式

class Solution:
    def delNodes(self, root: Optional[TreeNode], to_delete: List[int]) -> List[TreeNode]:
        to_delete_set = set(to_delete)
        roots = []
        self.dfs(root, True, to_delete_set, roots)
        return roots

    def dfs(self, node: Optional[TreeNode], is_root: bool, to_delete_set: set[int], roots: List[TreeNode]) ->  Optional[TreeNode]:
        if node == None:
            return None
        delete = node.val in to_delete_set
        node.left = self.dfs(node.left, delete, to_delete_set, roots)
        node.right = self.dfs(node.right, delete, to_delete_set, roots)
        if delete:
            return None
        else:
            if is_root:
                roots.append(node)
            return node

二叉搜索树

二叉搜索树(BST)的特性如下：

1、对于 BST 的每一个节点 node，左子树节点的值都比 node 的值要小，右子树节点的值都比 node 的值大。
2、对于 BST的每一个节点 node，它的左侧子树和右侧子树都是 BST。

BST有一个重要的性质：BST 的中序遍历结果是有序的（升序）。

230. 二叉搜索树中第K小的元素

# 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
class Solution:
    def __init__(self):
        self.ans = []

    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        self.backtrace(root)
        return self.ans[k - 1]

    def backtrace(self, root: Optional[TreeNode]):
        if not root:
            return
        self.backtrace(root.left)
        self.ans.append(root.val)
        self.backtrace(root.right)

538. 把二叉搜索树转换为累加树

此题中序遍历的顺序不一样
538. 把二叉搜索树转换为累加树

# 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
class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        self.backtrace(root, [0])
        return root

    def backtrace(self, root: Optional[TreeNode], sum):
        if not root:
            return
        self.backtrace(root.right, sum)
        sum[0] += root.val
        root.val = sum[0]
        self.backtrace(root.left, sum)