【leetcode】二叉树刷题总结（二）二叉树构造问题、最近公共祖先问题

二叉树构造问题

• 若二叉树序列化结果中不包含空指针的信息，且只给出一种遍历顺序，那么无法还原出唯一的一棵二叉树
• 若二叉树序列化结果中不包含空指针的信息，且给出两种遍历顺序，分两种情况：
  • 如果给出的是前序和中序，或者后序和中序，那么可以还原出唯一的一棵二叉树
  • 如果给出前序和后序，那么无法还原出唯一的一棵二叉树
• 若二叉树序列化结果中包含空指针的信息，且只给出一种遍历顺序，也要分两种情况：
  • 如果给出的是前序或者后序，那么可以还原出唯一的一棵二叉树
  • 如果给出的是中序，那么无法还原出唯一的一棵二叉树

LeetCode654题 最大二叉树

分解思路-递归法

# 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 constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return None
        max_index = None
        max_value = float('-inf')
        for i in range(len(nums)):
            if nums[i] > max_value:
                max_index = i
                max_value = nums[i]
        root = TreeNode(val=max_value)
        root.left = self.constructMaximumBinaryTree(nums[:max_index])
        root.right = self.constructMaximumBinaryTree(nums[max_index + 1:])
        return root

 LeetCode617题 合并二叉树

分解思路-递归法

# 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 mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1 and not root2:
            return None
        elif root1 and root2:
            root = TreeNode(root1.val + root2.val)
            root.left = self.mergeTrees(root1.left, root2.left)
            root.right = self.mergeTrees(root1.right, root2.right)
            return root
        else:
            root = root1 if root1 else root2
            return root

 LeetCode105题 从前序与中序遍历序列构造二叉树

先找到根节点，然后找到并递归构造左右子树即可：可以通过前序遍历结果找到根节点，然后根据中序遍历结果确定左右子树

分解思路-递归法

# 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 buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if len(inorder) == 0:
            return None
        root = TreeNode(val=preorder[0])
        split_index = None
        for i in range(len(inorder)):
            if inorder[i] == root.val:
                split_index = i
                break
        root.left = self.buildTree(preorder[1: split_index + 1], inorder[:split_index])
        root.right = self.buildTree(preorder[split_index + 1:], inorder[split_index + 1:])
        return root

 LeetCode106题 从中序与后序遍历序列构造二叉树

分解思路-递归法

# 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 buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        if len(inorder) == 0:
            return None
        root = TreeNode(val=postorder[-1])
        split_index = None
        for i in range(len(inorder)):
            if inorder[i] == root.val:
                split_index = i
                break
        root.left = self.buildTree(inorder[:split_index], postorder[:split_index])
        root.right = self.buildTree(inorder[split_index + 1:], postorder[split_index: -1])
        return root

 LeetCode889题 从前序和后序遍历构造二叉树

通过前序后序遍历结果无法确定唯一的原始二叉树

遍历思路-递归法

# 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 constructFromPrePost(self, preorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        root = TreeNode(val=preorder[0])
        self.traversal(preorder[1:], postorder[:-1], root)
        return root

    def traversal(self, preorder, postorder, cur):
        if not preorder:
            return
        if preorder[0] != postorder[-1]:
            cur.left = TreeNode(val=preorder[0])
            cur.right = TreeNode(val=postorder[-1])
            pre_idx = post_idx = None
            for i in range(len(preorder)):
                if preorder[i] == postorder[-1]:
                    pre_idx = i
                if postorder[i] == preorder[0]:
                    post_idx = i
            self.traversal(preorder[1: pre_idx], postorder[:post_idx], cur.left)
            self.traversal(preorder[pre_idx + 1:], postorder[post_idx + 1: -1], cur.right)
        else:
            # 产生不同结果的地方，这里选择一直放在左子树
            cur.left = TreeNode(val=preorder[0])
            self.traversal(preorder[1:], postorder[:-1], cur.left)

 LeetCode297题 二叉树的序列化与反序列化

前序遍历，迭代法实现

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

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        # 前序遍历
        if not root:
            return ''
        res = []
        stack = [root]
        while stack:
            node = stack.pop()
            if node is not None:
                res.append(str(node.val))
                stack.append(node.right)
                stack.append(node.left)
            else:
                res.append('#')
        return ' '.join(res)

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if data == '':
            return None
        data = data.split(' ')
        root = TreeNode(val=int(data[0]))
        stack = [(root, 'right'), (root, 'left')]
        index = 1
        while stack:
            parent, direction = stack.pop()
            if data[index] != '#':
                child = TreeNode(int(data[index]))
                if direction == 'left':
                    parent.left = child
                else:
                    parent.right = child
                stack.append((child, 'right'))
                stack.append((child, 'left'))
            index += 1
        return root

# Your Codec object will be instantiated and called as such:
# ser = Codec()
# deser = Codec()
# ans = deser.deserialize(ser.serialize(root))

最近公共祖先问题

LeetCode236题 二叉树的最近公共祖先

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

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root is None or root == p or root == q:
            return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        # 如果左右子树的返回值都不为空，说明此时的中节点，一定是q和p的最近祖先
        if left is not None and right is not None:
            return root
        elif left is not None and right is None:
            return left
        elif left is None and right is not None:
            return right
        else:
            return None

 LeetCode235题 二叉搜索树的最近公共祖先

分解思路-递归法

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

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root:
            return
        if root.val < p.val and root.val < q.val:
            return self.lowestCommonAncestor(root.right, p, q)
        elif root.val > p.val and root.val > q.val:
            return self.lowestCommonAncestor(root.left, p, q)
        else:
            return root