Leetcode刷题系列（四）Binary Tree相关

Binary Tree的遍历

Binary Tree的遍历思想

　　Binary Tree的遍历一般有前序、中序、后序和层序遍历：

前序遍历：根->左子树->右子树

中序遍历：左子树->根->右子树

后序遍历：左子树->右子树->根

层序遍历：按层数来

　　具体遍历就不行进举例了。

Binary Tree的遍历－使用递归

　　使用递归是二叉树遍历最为简单的一种方法，下面给出前序遍历的代码版本１：

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);
}
}

　　版本２（分治）：

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;
}
}

　　版本２使用的是分治法，它与递归的最大不同之处在于它有返回值，这样可得到较小问题的答案来解决大问题，但是分治算法大多数情况下要比动态规划算法时间复杂度大，因为分治算法并没有记住较小问题的答案，再次使用较小问题的答案时需要重新进行计算。

　　上诉的算法可通用在中序和后序算法上，只需要将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