树 236. 二叉树的最近公共祖先 105. 从前序与中序遍历序列构造二叉树 102. 二叉树的层序遍历

最新推荐文章于 2022-03-19 11:07:15 发布

青柠17

最新推荐文章于 2022-03-19 11:07:15 发布

阅读量209

点赞数

分类专栏： # 树 Leetcode

本文链接：https://blog.csdn.net/yhhuang17/article/details/105254792

版权

Leetcode 同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

树

5 篇文章 0 订阅

订阅专栏

236. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例：

给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
在这里插入图片描述

示例 1:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

思路1：递归

这种方法非常直观。先深度遍历改树。当你遇到节点 p 或 q 时，返回一些布尔标记。该标志有助于确定是否在任何路径中找到了所需的节点。最不常见的祖先将是两个子树递归都返回真标志的节点。它也可以是一个节点，它本身是p或q中的一个，对于这个节点,子树递归返回一个真标志。

算法：

从根节点开始遍历树。
如果当前节点本身是 p 或 q 中的一个，我们会将变量 mid 标记为 true，并继续搜索左右分支中的另一个节点。
如果左分支或右分支中的任何一个返回 true，则表示在下面找到了两个节点中的一个。
如果在遍历的任何点上，左、右或中三个标志中的任意两个变为 true，这意味着我们找到了节点 p 和 q 的最近公共祖先。

代码实现1：

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

class Solution:
    def __init__(self):
        self.ans = None

    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        
        def recurse_tree(cur_node):
            if cur_node is None:
                return False
            # 向左递归寻找，再向右递归寻找
            left = recurse_tree(cur_node.left)
            right = recurse_tree(cur_node.right)
			# 如果当前节点左右子树都为False，判断当前节点是否为目标值其中之一
            mid = True if cur_node == p or cur_node == q else False
			# 满足左子树、右子树、当前节点 三个中两个为真，则当前节点为公共祖先
            if mid + left + right >= 2:
                self.ans = cur_node
            # 只要左子树、右子树、当前节点有一个为真，返回真
            return mid or left or right
        
        recurse_tree(root)
        return self.ans

105. 从前序与中序遍历序列构造二叉树

根据一棵树的前序遍历与中序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。

示例：

给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：
    3
   / \
  9  20
    /  \
   15   7

思路：递归

前序遍历的特点是，根节点始终出现在数组的第一位，而中序遍历中根节点出现在数组的中间位置。
根据上面给出的两个数组，首先我们就可以拼出根节点，它就是1。
题目上已说明数组中不存在重复元素，那么由1就可以定位到中序数组的中间位置，中序数组中1左边的部分就是左子树，1右边部分就是右子树。
在这里插入图片描述
下面这张图，根节点是橘色，绿色部分是左子树，蓝色部分是右子树。

前序数组的左子树部分+根节点是1,2,4,5，中序数组的左子树部分+根节点是4,2,5,1。这两者的数组长度是一样的。
我们可以根据中序数组的中间位置1，来确定前序数组的左右部分，由于前序数组第一个是根节点，
所以其左边部分是：[1:mid_index]，右半部分是[mid_index+1:]
这里的mid_index是中序数组的中间下标位置。
递归函数实现如下：

终止条件:前序和中序数组为空
根据前序数组第一个元素，拼出根节点，再将前序数组和中序数组分成两半，递归的处理前序数组左边和中序数组左边，递归的处理前序数组右边和中序数组右边。

在这里插入图片描述

代码实现：

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

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
            if not (preorder and inorder):
                return None
            # 根据前序数组的第一个元素，确定根节点
            root = TreeNode(preorder[0])
            # 找到根节点在中序数组中的索引
            mid_index = inorder.index(preorder[0])
            # 递归的处理前序和中序数组的左边部分
            root.left = self.buildTree(preorder[1:mid_index+1], inorder[:mid_index])
            # 递归的处理前序和中序数组的右边部分
            root.right = self.buildTree(preorder[mid_index+1:], inorder[mid_index+1:])
            return root

94. 二叉树的中序遍历

给你一个二叉树，请你返回其按层序遍历得到的节点值。（即逐层地，从左到右访问所有节点）。

示例：

二叉树：[3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
   
返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]

思路1：迭代

代码实现1：

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

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        queue = [root]
        ret = []
        while queue:
        	# 获取当前队列长度，即当前层的节点个数
            size = len(queue)
            temp = []
            # 从队列中获取当前层所有节点，放入临时列表temp中，同时将当前层所有左右子树放入队列
            for _ in range(size):
                r = queue.pop(0)
                temp.append(r.val)
                if r.left:
                    queue.append(r.left)
                if r.right:
                    queue.append(r.right)
            # 将临时列表放入结果列表中
            ret.append(temp)
        return ret

思路2：递归

把二叉树的样子调整一下，摆成一个田字形的样子。田字形的每一层就对应一个list。
在这里插入图片描述

按照深度优先的处理顺序，会先访问节点1，再访问节点2，接着是节点3。
之后是第二列的4和5，最后是第三列的6。
每次递归的时候都需要带一个index(表示当前的层数)，也就对应那个田字格子中的第几行，如果当前行对应的list不存在，就加入一个空list进去。

代码实现2：

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

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        ret = []
        if not root:
            return ret
        
        def helper(node, layer):
        	# 如果结果列表长度与当前层数相等，则在结果列表中加入一个空列表
            if len(ret) == layer:
                ret.append([])
            # 向当前层的列表中添加元素
            ret[layer].append(node.val)
			# 递归向左右子树添加，并将层数+1
            if node.left:
                helper(node.left, layer + 1)
            if node.right:
                helper(node.right, layer + 1)

        helper(root, 0)
        return ret