2. 二叉树

目录

• 中序遍历 & 层次遍历
• 从前序&中序遍历构造二叉树
• 判断是否为平衡二叉树
• 二叉树翻转
• 最近公共的祖先
• 二叉树的最大路径和

中序遍历 & 层次遍历

• leetcode-中序遍历
• leetcode-层次遍历

from typing import List

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


class Traversal:
    # 中序遍历： 
    def inorderTraversal(self, root: TreeNode):
        if not root:
            return []
        stack = []
        res = []
        while root or len(stack) > 0:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            res.append(root.val)
            root = root.right
        return res

    # 层次遍历
    def levelOrder(self, root: TreeNode):
        if not root:
            return []
        stack = [root]
        res = []
        while len(stack) > 0:
            level_size = len(stack)
            level_node = []
            for _ in range(level_size):
                root = stack.pop(0)
                if root.left:
                    stack.append(root.left)
                if root.right:
                    stack.append(root.right)
                level_node.append(root.val)
            res.append(level_node)
        return res

从前序&中序遍历构造二叉树

class ConstructBinaryTree:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if not preorder or not inorder:
            return None
        n = len(inorder)
        if n != len(preorder):
            return None

        def buildMyTree(preleft, preright, inleft, inright):
            if preleft > preright:
                return None
            node = TreeNode(preorder[preleft])
            i = index[preorder[preleft]]
            size = i - inleft
            node.left = buildMyTree(preleft + 1, preleft + size, inleft, i)
            node.right = buildMyTree(preleft + size + 1, preright, i + 1, inright)
            return node

        index = {ele: idx for idx, ele in enumerate(inorder)}
        root = buildMyTree(0, n - 1, 0, n - 1)
        return root

判断是否为平衡二叉树

class BalancedBinaryTree:
    def isBalanced(self, root: TreeNode) -> bool:
        if root is None:
            return True
        left = self.getHeight(root.left)
        right = self.getHeight(root.right)
        return abs(left - right) <= 1 and self.isBalanced(root.left) and self.isBalanced(root.right)

    def getHeight(self, root):
        if root is None:
            return 0
        if root.left is None and root.right is None:
            return 1
        left, right = 0, 0
        if root.left:
            left = self.getHeight(root.left)
        if root.right:
            right = self.getHeight(root.right)
        return 1 + max(left, right)

二叉树翻转

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return root
        self.mirrorTree(root.left)
        self.mirrorTree(root.right)
        root.left, root.right = root.right, root.left
        return root

最近公共的祖先

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root is None:
            return None
        if root == p or root == q:
            return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        if left and right:
            return root
        elif left:
            return left
        return right

二叉树的最大路径和

class Solution:
    def __init__(self):
        self.maxSum = float("-inf")

    def maxPathSum(self, root: TreeNode) -> int:
        def maxGain(node):
            if not node:
                return 0

            # 递归计算左右子节点的最大贡献值
            # 只有在最大贡献值大于 0 时，才会选取对应子节点
            leftGain = max(maxGain(node.left), 0)
            rightGain = max(maxGain(node.right), 0)

            # 节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值
            priceNewpath = node.val + leftGain + rightGain

            # 更新答案
            self.maxSum = max(self.maxSum, priceNewpath)

            # 返回节点的最大贡献值
            return node.val + max(leftGain, rightGain)

        maxGain(root)
        return self.maxSum