关于算法面试中涉及Binary Tree的问题

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">Binary Tree的定义这里就不用说啦，主要会涉及到下面几个问题:</span>

1. Binary Tree DFS Traversal

    首先是三种DFS遍历方式, preorder / inorder / postorder. 而每种遍历方式又都可以用recursion method 和 while - loop 两种方法实现。递归方式相对简单，面试时要用while - loop的方法。

    先给个preorder的两种实现方法:

// DFS preorder traversal implemented by recursion
public class PreOrderByRecursion{
public ArrayList<Integer> preOrderTraversal(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
traversal(root, result);
return result;
}

private void traversal(TreeNode root, ArrayList<Integer> result) {
if (root == null) {   // stop condition
return list;
}

result.add(root.val);
traversal(root.left, result);
traversal(root.right, result);
}
}

<pre name="code" class="java"><span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">    上面是递归方式，下面着重看看如何用非递归方式实现前序遍历</span>

<pre name="code" class="java">/*
* while-loop method
* use stack to memorize
*/
public class Pre0rderByInteration{
private ArrayList<Integer> preOrderTraversal(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
Stack<TreeNode> stack = new Stack<TreeNode>();

if (root == null) {
return result;
}

stack.push(root);
while (!stack.empty()) {
TreeNode node = stack.pop();
result.add(node.val);
if (node.right != null) {
stack.push(node.right);
}
if (node.right != null) {
stack.push(node.left);
}
}
return result;
}
}

    然后是inoder的两种实现方法:

// DFS inorder traversal implemented by recursion
public class InOrderByRecursion{
public ArrayList<Integer> inOrderTraversal(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
traversal(root, result);
return result;
}

private void traversal(TreeNode root, ArrayList<Integer> result) {
if (root == null) {   // stop condition
return list;
}

traversal(root.left, result);
result.add(root.val);
traversal(root.right, result);
}
}

中序列遍历的递归方法就是在前序递归遍历的基础上改变一下顺序, 比较简单,  而非递归方法就不单单只是改变一下stack的插入顺序了, 而是从根节点开始，先插入所有的左子节点，如果出现null，则从栈取出一个，然后指针变为其右子节点。

public class In0rderByInteration{
private ArrayList<Integer> inorderTraversalByIteration(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();

if (root == null) {
return result;
}

Stack<TreeNode> stack = new Stack<TreeNode>();

while (!stack.empty() || root != null) {
while (root != null) {   // 如果该节点不为空，则将该节点放入栈中，并将指针p置为其左孩子，然后进行相同操作
stack.push(root);
root = root.left;
}
if (!stack.empty()) {
root = stack.pop();
result.add(root.val);
root = root.right;
}
}
return result;
}
}

最后是postorder, 首先还是写比较简单的递归方式

// DFS postorder traversal implemented by recursion
public class PostOrderByRecursion{
public ArrayList<Integer> postOrderTraversal(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
traversal(root, result);
return result;
}

private void traversal(TreeNode root, ArrayList<Integer> result) {
if (root == null) {   // stop condition
return list;
}

traversal(root.left, result);
traversal(root.right, result);
result.add(root.val);
}
}

后序遍历的非递归方法是这三种遍历中最难的，对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问，因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是否是第一次出现在栈顶。

public class Post0rderByInteration{
private ArrayList<Integer> postOrderTraversalByIteration(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode curr = root;

if (root == null) {
return result;
}

while (curr != null || !stack.empty()) {
if (curr != null) {
stack.push(curr);
curr.isFirst = true;   // first visited
curr = curr.left;
} else {
TreeNode node = stack.pop();
if (!node.isFirst) {    // visit the node here
result.add(node.val);

} else {
node.isFirst = false;
stack.push(node);
curr = node.right;
}
}

}
return result;
}
}

2. Divid & Conque Algorithm

   凡是binary tree的问题差不多都可以用分治法来解决，要掌握分治法的模版 merge sort是最典型的例子，下面看几道leetcode题：

   2.1  Binary Tree Max Path Sum

          The path may start and end in any node.

   我们说binary tree的问题差不多都可以用分治法来解决，那么下面让我们看看如果用分治思想来解决这道题

   求最大路径，给一个根节点root，那么这个最大路径可能出现在根节点的左子树，也可能出现在根节点的右子数，也可以跨过根节点，对于最后一种情况，我们只

   需要先求出包含根节点的最大左子数路径，再加上最大右子树路径，然后再减去根节点的值。

public class Solution {
// store max value
int max;

public int maxPathSum(TreeNode root) {
if (root == null) {
max = 0;
} else {
max = root.val;
}
findMax(root);
return max;
}

private int findMax(TreeNode root) {
if (root == null) {
return 0;
}

// Divide
int left = Math.max(findMax(root.left), 0);
int right = Math.max(findMax(root.right), 0);

// update maximum here
max = Math.max(root.val + left + right, max);

// return sum of largest path of current node
return root.val + Math.max(left, right);
}
}
2. Binary Tree Level Order Traversal

    这道体的一般方法就是用两个列队分别存储正在遍历的level和next level，不过也可以用一个queue来实现。其实就是利用双循环，先求出queue的siaze。

public class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
if (root == null) {
return result;
}
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while (!queue.isEmpty()) {
int size = queue.size();
List<Integer> list = new ArrayList<Integer>()
9ffb
;
for (int i = 0; i < size; i++) {
TreeNode node = queue.poll();
list.add(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if(node.right != null) {
queue.offer(node.right);
}
}
result.add(list);
}
return result;
}
}