leetcode刷题-100~105

题目100题

相同的树

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:  1       1
       /     /
      2   3 2    3

[1,2,3], [1,2,3]

输出: true

思路

深度优先遍历：

　　当两个二叉树都为空，则两个二叉树相同。

　　当两个二叉树中有且只有一个为空，则两个二叉树一定不相同。

　　当二叉树都不为空时，判定根节点的值是否相同。

　　递归查询其左子树和右子树。

实现

# 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 isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if p == None and q == None:
            return True
        elif p == None or q == None:
            return False
        elif p.val != q.val:
            return False
        else:
            return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

题目101题

对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

     1
    /
   2   2
  / /
  3 4 4 3
 

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

     1
    /
   2  2
       
     3   3

思路

两个树互为镜像的条件：

1.它们的两个根结点具有相同的值

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 isSymmetric(self, root: TreeNode) -> bool:
        def check(left: TreeNode, right:TreeNode) -> bool:
            if not left and not right:
                return True
            elif not left or not right:
                return False
            elif left.val != right.val:
                return False
            else:
                return check(left.left, right.right) and check(left.right, right.left)
        return check(root, root)

题目102题

二叉树的层次遍历

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

示例：
二叉树：[3,9,20,null,null,15,7],

      3
     /
    9 20
      / 
     15   7
返回其层次遍历结果：

[
[3],
[9,20],
[15,7]
]

思路

给每个节点增加一个在第几层的设定，通过递归实现，每向下遍历左子树和右子树，则下一层的level增加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]]:
        def helper(node: TreeNode, result, lev):
            if node:
                if len(result) <= lev:
                    result.append([])
                result[lev].append(node.val)
                if node.left:
                    helper(node.left, result,lev+1)
                if node.right:
                    helper(node.right, result,lev+1)

        level = 0
        result = []
        helper(root, result, level)
        return result

题目103题

二叉树的锯齿形层次遍历

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：
给定二叉树 [3,9,20,null,null,15,7],

   3
  /
 9  20
     /
    15  7
返回锯齿形层次遍历如下：

[
[3],
[20,9],
[15,7]
]

思路

此题与102题非常的类似，同样使用的是深度优先遍历DFS，但是其要求锯齿状遍历，因此可以根据其层数决定其插入方式，若层数为偶数(从0层开始)，则新元素添加在末尾，若层数为基数，新元素添加在开头。

实现

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

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        def helper(node: TreeNode, result, lev):
            if root:
                if len(result) <= lev:
                    result.append([])
                if lev % 2 == 0:
                    result[lev].append(node.val)
                else:
                    result[lev].insert(0, node.val)
                if node.left:
                    helper(node.left, result,lev+1)
                if node.right:
                    helper(node.right, result,lev+1)
                

        level = 0
        result = []
        helper(root, result, level)
        return result

题目104题

二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

       3
      /
     9  20
         /
       15   7
返回它的最大深度 3

思路

此题方法很多，深度优先/递归都可实现

实现

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

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root is None:
            return 0
        self.result = 1
        def inorder(tree, res):
            if tree != None:
                if res >= self.result:
                    self.result = res
                if tree.left != None:
                    inorder(tree.left, res + 1)
                if tree.right != None:
                    inorder(tree.right, res + 1)
        inorder(root, self.result)
        return self.result

#递归
class Solution:
    def maxDepth(self, root):
        if root is None: 
            return 0 
        else: 
            left = self.maxDepth(root.left) 
            right = self.maxDepth(root.right) 
            return max(left, right) + 1 

题目105题

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

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

   3
  /
 9  20
     /
   15   7

思路

只要在中序遍历中定位到根节点，就可以分别知道左子树和右子树中的节点数目。由于同一颗子树的前序遍历和中序遍历的长度显然是相同的，因此我们就可以对应到前序遍历的结果中，对上述形式中的所有左右括号进行定位。

实现

# 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:
        def build(preorder_left, preorder_right, inorder_left, inorder_right):
            if preorder_left > preorder_right:
                return None
            new_root = preorder[preorder_left]
            root = TreeNode(new_root)
            index = inorder.index(new_root)
            left_size = index - inorder_left
            root.left = build(preorder_left + 1, preorder_left + left_size, inorder_left, index - 1)
            root.right = build(preorder_left + left_size + 1, preorder_right, index + 1, inorder_right)
            return root
        n = len(preorder)
        return build(0, n - 1, 0, n - 1)