Binary Tree的遍历
Binary Tree的遍历思想
Binary Tree的遍历一般有前序、中序、后序和层序遍历:
- 前序遍历:根->左子树->右子树
- 中序遍历:左子树->根->右子树
- 后序遍历:左子树->右子树->根
层序遍历:按层数来
具体遍历就不行进举例了。
Binary Tree的遍历-使用递归
使用递归是二叉树遍历最为简单的一种方法,下面给出前序遍历的代码版本1:
public class Solution {
public ArrayList<Integer> preorderTraversal(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
traverse(root, result);
return result;
}
// 把root为跟的preorder加入result里面
private void traverse(TreeNode root, ArrayList<Integer> result) {
if (root == null) {
return;
}
result.add(root.val);
traverse(root.left, result);
traverse(root.right, result);
}
}
版本2(分治):
public class Solution {
public ArrayList<Integer> preorderTraversal(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
// null or leaf
if (root == null) {
return result;
}
// Divide
ArrayList<Integer> left = preorderTraversal(root.left);
ArrayList<Integer> right = preorderTraversal(root.right);
// Conquer
result.add(root.val);
result.addAll(left);
result.addAll(right);
return result;
}
}
版本2使用的是分治法,它与递归的最大不同之处在于它有返回值,这样可得到较小问题的答案来解决大问题,但是分治算法大多数情况下要比动态规划算法时间复杂度大,因为分治算法并没有记住较小问题的答案,再次使用较小问题的答案时需要重新进行计算。
上诉的算法可通用在中序和后序算法上,只需要将result.add的顺序按照所需遍历顺序进行改变即可。另外,层序遍历是无法使用递归实现的。
Binary Tree的遍历-非递归(使用栈)
前序遍历(preorder)
二叉树前序遍历的非递归实现使用一个栈就可以轻松解决。先把根节点加入栈中,再把其左节点和右节点按顺序入栈,出栈的顺序即为遍历的顺序,这样就不给出代码了。
中序遍历(inorder)
中序遍历思想也较为简单,先去访问到最左边的节点,然后是根节点,借着转向右节点然后重复刚才的操作,关键代码:
while (curt != null || !stack.empty()) {
while (curt != null) {
stack.add(curt);
curt = curt.left;
}
curt = stack.peek();
stack.pop();
result.add(curt.val);
curt = curt.right;
}
后序遍历(postorder)
后序遍历也使用一个栈来解决,但是思路不及上面两种遍历简单清晰。关键代码:
while (!stack.empty()) {
curr = stack.peek();
if (prev == null || prev.left == curr || prev.right == curr) {
if (curr.left != null) {
stack.push(curr.left);
} else if (curr.right != null) {
stack.push(curr.right);
}
} else if (curr.left == prev) {
if (curr.right != null) {
stack.push(curr.right);
}
} else {
result.add(curr.val);
stack.pop();
}
prev = curr;
}
因为后序遍历的顺序为:左子树->右子树->根,因此第一个if为访问到最左边,第二个if为左子树访问完毕需要回溯去访问右子树,第三个为右子树也访问完毕,可以访问根节点了。
需要注意的是节点是否为null的检查,这在任何遍历程序中都需要。
层序遍历(level order)
层序遍历不能使用递归来实现,但是非递归方法却很多。层序遍历按思想上来说本身就是一种广度优先搜索,因此使用广度优先搜索较为简单,可以使用一个队列或两个队列来实现,一个队列则与先序遍历相似,逐个添加然后按顺序出队列,两个队列的实现主要思想是一个装着之前的节点,另一个队列用来装新访问的节点(新一层)。这里给出使用一个队列的代码:
public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
ArrayList result = new ArrayList();
if (root == null) {
return result;
}
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while (!queue.isEmpty()) {
ArrayList<Integer> level = new ArrayList<Integer>();
int size = queue.size();
for (int i = 0; i < size; i++) {
TreeNode head = queue.poll();
level.add(head.val);
if (head.left != null) {
queue.offer(head.left);
}
if (head.right != null) {
queue.offer(head.right);
}
}
result.add(level);
}
return result;
}
除了使用BFS的方法,还可使用DFS的方法,但这个就较为别扭了,还需要在遍历的时候加上访问的层次信息,这里就不给出代码了。
Binary Tree的分治法
前面给出过前序遍历二叉树的分治解法,分治法也可以用来解决一些关于二叉树的题。
Maximum Depth of Binary Tree
题目为求二叉树的最大深度,使用分治法可以很简单的解决该问题:
public int maxDepth(TreeNode root) {
if (root == null) {
return 0;
}
int left = maxDepth(root.left);
int right = maxDepth(root.right);
return Math.max(left, right) + 1;
}
Binary Tree Maximum Path Sum
题目为寻找一条路径使其路径和最大,路径可以在任一节点中开始和结束(路径和为两个节点之间所在路径上的节点权值之和)。我们使用一种额外的数据类型,包含两个整数值:
- singlePath: 从root往下走到任意点的最大路径,这条路径可以不包含任何点
maxPath: 从树中任意到任意点的最大路径,这条路径至少包含一个点
代码如下,最后结果返回maxPath即可。
private ResultType helper(TreeNode root) {
if (root == null) {
return new ResultType(0, Integer.MIN_VALUE);
}
// Divide
ResultType left = helper(root.left);
ResultType right = helper(root.right);
// Conquer
int singlePath = Math.max(left.singlePath, right.singlePath) + root.val;
singlePath = Math.max(singlePath, 0);
int maxPath = Math.max(left.maxPath, right.maxPath);
maxPath = Math.max(maxPath, left.singlePath + right.singlePath + root.val);
return new ResultType(singlePath, maxPath);
}
Lowest Common Ancestor
题目为寻找两个节点最近的公共祖先节点。此题也可以使用分治法:
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode node1, TreeNode node2) {
if (root == null || root == node1 || root == node2) {
return root;
}
// Divide
TreeNode left = lowestCommonAncestor(root.left, node1, node2);
TreeNode right = lowestCommonAncestor(root.right, node1, node2);
// Conquer
if (left != null && right != null) {
return root;
}
if (left != null) {
return left;
}
if (right != null) {
return right;
}
return null;
}
在root为根的二叉树中找A,B的LCA:
- 如果找到了就返回这个LCA
- 如果只碰到A,就返回A
- 如果只碰到B,就返回B
- 如果都没有,就返回null