目录
第一题:二叉树的最大深度
给定一个二叉树,找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
解题思路:
- 如果我们知道了左子树和右子树的最大深度 l 和 r,那么该二叉树的最大深度即为max(l,r)+1而左子树和右子树的最大深度又可以以同样的方式进行计算。
- 在计算当前二叉树的最大深度时,可以先递归计算出其左子树和右子树的最大深度,然后在 O(1) 时间内计算出当前二叉树的最大深度。递归在访问到空节点时退出。
代码实现:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int maxDepth(TreeNode root) {
if(root == null) {
return 0;
}
int leftH = maxDepth(root.left);
int rightH = maxDepth(root.right);
return leftH > rightH ? leftH+1 : rightH+1;
}
}
第二题:二叉树的前序遍历
解题思路:
- 定义 preorder(root) 表示当前遍历到 root 节点的答案。
- 按照定义,我们只要首先将 root 节点的值加入答案,然后递归调用 preorder(root.left) 来遍历 root 节点的左子树,最后递归调用 preorder(root.right) 来遍历 root 节点的右子树即可,递归终止的条件为碰到空节点
代码实现:
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> ret = new ArrayList<>();
if(root == null) {
return ret;
}
preorder(ret,root);
return ret;
}
private List<Integer> preorder(List<Integer> ret,TreeNode root) {
if(root == null) {
return null;
}
ret.add(root.val);
preorder(ret,root.left);
preorder(ret,root.right);
return ret;
}
}
第三题:二叉树的中序遍历
给定一个二叉树的根节点 root ,返回 它的 中序 遍历 。
示例 1:
输入:root = [1,null,2,3]
输出:[1,3,2]
示例 2:
输入:root = []
输出:[]
示例 3:
输入:root = [1]
输出:[1]
提示:
- 树中节点数目在范围 [0, 100] 内
- -100 <= Node.val <= 100
解题思路
- 定义 inorder(root) 表示当前遍历到 root 节点的答案。
- 按照定义,我们只要首先递归调用 inorder(root.left) 来遍历 root 节点的左子树,然后将 root 节点的值加入答案,最后递归调用 inorder(root.right) 来遍历 root 节点的右子树即可,递归终止的条件为碰到空节点
代码实现:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> ret = new ArrayList<>();
if(root == null) {
return ret;
}
inorder(ret,root);
return ret;
}
private List<Integer> inorder(List<Integer> ret,TreeNode root) {
if(root == null) {
return null;
}
inorder(ret,root.left);
ret.add(root.val);
inorder(ret,root.right);
return ret;
}
}
第四题:二叉树的后序遍历
给你一棵二叉树的根节点 root ,返回其节点值的 后序遍历 。
示例 1:
输入:root = [1,null,2,3]
输出:[3,2,1]
示例 2:
输入:root = []
输出:[]
示例 3:
输入:root = [1]
输出:[1]
提示:
- 树中节点的数目在范围 [0, 100] 内
- -100 <= Node.val <= 100
解题思路:
- 定义 postorder(root) 表示当前遍历到 root 节点的答案。
- 按照定义,我们只要首先递归调用 postorder(root.left) 来遍历 root 节点的左子树,然后递归调用 postorder(root.right) 来遍历 root 节点的右子树,最后将 root 节点的值加入答案即可,递归终止的条件为碰到空节点
代码实现:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> ret = new ArrayList<>();
if(root == null) {
return ret;
}
postorder(ret,root);
return ret;
}
private List<Integer> postorder(List<Integer> ret,TreeNode root) {
if(root == null) {
return null;
}
postorder(ret,root.left);
postorder(ret,root.right);
ret.add(root.val);
return ret;
}
}
第五题:二叉树的程序遍历
给你二叉树的根节点 root ,返回其节点值的 层序遍历 。 (即逐层地,从左到右访问所有节点)。
示例 1:
输入:root = [3,9,20,null,null,15,7]
输出:[[3],[9,20],[15,7]]
示例 2:
输入:root = [1]
输出:[[1]]
示例 3:
输入:root = []
输出:[]
提示:
- 树中节点数目在范围 [0, 2000] 内
- -1000 <= Node.val <= 1000
解题思路:
- 使用数组接收每一层的元素,再用数组接收每一层的数组
- 如果root不为空,使用队列接收root,然后取出root并判断左右孩子会否为空,若不为空,则放入,将root放入curRow中,size-1,循环结束后,返回ret
代码实现:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> ret = new ArrayList<>();
if(root == null) {
return ret;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()) {
List<Integer> curRow = new ArrayList<>();
int size = queue.size();
while(size != 0) {
TreeNode cur = queue.poll();
curRow.add(cur.val);
if(cur.left != null) {
queue.offer(cur.left);
}
if(cur.right != null) {
queue.offer(cur.right);
}
size--;
}
ret.add(curRow);
}
return ret;
}
}