一.二叉树的最大深度
给定一个二叉树,找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7]
,
3 / \ 9 20 / \ 15 7
返回它的最大深度 3 。
我的解答:
如果根节点为空,则深度为0,返回0,递归的出口
如果根节点不为空,那么深度至少为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 maxDepth(self, root): """ :type root: TreeNode :rtype: int """ left = 1 right = 1 if not root: return 0 else: left = left + self.maxDepth(root.left) right = right + self.maxDepth(root.right) if left >= right: return left else: return right
二.验证二叉搜索树
给定一个二叉树,判断其是否是一个有效的二叉搜索树。
一个二叉搜索树具有如下特征:
- 节点的左子树只包含小于当前节点的数。
- 节点的右子树只包含大于当前节点的数。
- 所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入: 2 / \ 1 3 输出: true
示例 2:
输入: 5 / \ 1 4 / \ 3 6 输出: false 解释: 输入为: [5,1,4,null,null,3,6]。 根节点的值为 5 ,但是其右子节点值为 4 。
我的解答:
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 isValidBST(self, root): """ :type root: TreeNode :rtype: bool """ #根节点为None的情况——返回True if not root: return True else: #没有叶子结点,搜索到了终点,返回True if not root.left and not root.right: return True #没有左边结点、右边结点满足二叉搜索树条件情况 elif not root.left: if root.right.val > root.val: return self.isValidBST(root.right) else: return False #没有右边结点、左边结点满足二叉搜索树条件情况 elif not root.right: if root.left.val < root.val: return self.isValidBST(root.left) else: return False #左右结点均满足二叉搜索树条件情况 elif root.left.val < root.val and root.right.val > root.val: return self.isValidBST(root.left) and self.isValidBST(root.right) #左右结点只要有一个不满足二叉搜索树情况 else: return False
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 isValidBST(self, root): """ :type root: TreeNode :rtype: bool """ return self.isValidBST_f2(root,-2**32,2**32-1) #从上往下比较,每个节点往左就是最大,往右就是最小值 #传输过程中原函数不能够传递最大最小值,又重新定义了一个函数调用 def isValidBST_f2(self,root,small,large): if not root: return True elif root.val >= large or root.val <= small: return False else: return self.isValidBST_f2(root.left,small,root.val) and self.isValidBST_f2(root.right,root.val,large)
三.对称二叉树
给定一个二叉树,检查它是否是镜像对称的。
例如,二叉树 [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
说明:
如果你可以运用递归和迭代两种方法解决这个问题,会很加分。
我的解答:
这里将根节点的左右节点假设成两颗独立的树,这样解题跟题目100就是类似的了,区别:递归调用时,因是对称,所以是左树左节点与右树右节点,左树右节点与右树左节点
# 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): """ :type root: TreeNode :rtype: bool """ #这里将根节点的左右节点假设成两颗独立的树,这样解题跟100就是类似的了,区别:递归调用时,因是对称,所以是左树左节点与右树右节点,左树右节点与右树左节点 #定义 def isSameTree(p,q): if not p and not q: #左右数均为空,返回True return True elif p and q and p.val == q.val: #递归,每次重新从函数入口处进行,每次进行递归边界判断 l = isSameTree(p.left,q.right) r = isSameTree(p.right,q.left) return l and r else: return False #调用 if not root: return True else: return isSameTree(root.left,root.right)
四.二叉树的层次遍历
给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。
例如:
给定二叉树: [3,9,20,null,null,15,7]
,
3 / \ 9 20 / \ 15 7返回其层次遍历结果:
[ [3], [9,20], [15,7] ]
我的解答:
广度优先搜索BFS实现
队列:用一个队列,把当前点加进去,从这个点开始尝试所有可能的方向,尝试完以后把这个点出队,然后对还在队里的点(也就是刚才入队的点)继续同样的步骤,直到达到目的。
# 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): """ :type root: TreeNode :rtype: List[List[int]] """ #广度优先搜索BFS实现(队列:用一个队列,把当前点加进去,从这个点开始尝试所有可能的方向,尝试完以后把这个点出队,然后对还在队里的点(也就是刚才入队的点)继续同样的步骤,直到达到目的。) if not root: return [] queue = [root] node = [] res = [] while queue: nodes = [] node_value = [] #下面是把这一层的所有节点的值全部取出来(放入到node_value中)、并且把子节点全部求出来(放入到nodes中) for node in queue: if node.left: nodes.append(node.left) if node.right: nodes.append(node.right) node_value = node_value + [node.val] queue = nodes #子节点存储到queue变量中 res.append(node_value) #节点的值保存在res变量中 return res
五.将有序数组转换为二叉搜索树
将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索树。
本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定有序数组: [-10,-3,0,5,9], 一个可能的答案是:[0,-3,9,-10,null,5],它可以表示下面这个高度平衡二叉搜索树: 0 / \ -3 9 / / -10 5
我的解答:
本质上是运用二分查找法!
# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: def sortedArrayToBST(self, nums): """ :type nums: List[int] :rtype: TreeNode """ if not nums: return None mid = len(nums)//2 #得到中点 root = TreeNode(nums[mid]) #root为树的根节点 #下面是递归过程(左子树和右子树继续二分得到中间值) root.left = self.sortedArrayToBST(nums[:mid]) root.right = self.sortedArrayToBST(nums[mid+1:]) #这里注意——中间节点已经给了root了,所以从mid+1开始 return root