关于算法面试中涉及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>();
            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;
    }
}