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)
