二叉树的前序、中序、后序遍历

分别使用traverse、divide & conquer、non-recursion来实现。
traverse使用全局遍历，不需要返回值。
divide & conquer 两步走：first :divide second:conquer
non-recursion：借助栈来实现。其中后序遍历与先右后左的前序遍历互为逆序，借助这一性质来简化操作。

traverse:

• 前序遍历

public class Solution {    /**     * @param root: The root of binary tree.     * @return: Preorder in ArrayList which contains node values.     */    public ArrayList<Integer> preorderTraversal(TreeNode root) {        ArrayList<Integer> result = new ArrayList<Integer>();        traverse(root, result);        return 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 {    /**     * @param root: The root of binary tree.     * @return: Inorder in ArrayList which contains node values.     */    public ArrayList<Integer> inorderTraversal(TreeNode root) {        ArrayList<Integer> inorder = new ArrayList<Integer>();        traverse(root, inorder);        return inorder;    }    private void traverse(TreeNode root, ArrayList<Integer> inorder) {        if (root == null) {            return;        }        traverse(root.left, inorder);        inorder.add(root.val);        traverse(root.right, inorder);    }}

• 后序遍历

public class Solution {    /**     * @param root: The root of binary tree.     * @return: Postorder in ArrayList which contains node values.     */    public ArrayList<Integer> postorderTraversal(TreeNode root) {        ArrayList<Integer> postorder = new ArrayList<>();        traverse(root, postorder);        return postorder;    }    private void traverse(TreeNode root, ArrayList<Integer> postorder) {        if (root == null) {            return;        }        traverse(root.left, postorder);        traverse(root.right, postorder);        postorder.add(root.val);    }}

Divide & Conquer

public class Solution {    /**     * @param root: The root of binary tree.     * @return: Preorder in ArrayList which contains node values.     */    public ArrayList<Integer> preorderTraversal(TreeNode root) {        ArrayList<Integer> result = new ArrayList<Integer>();        if (root == null) {            return result;        }        ArrayList<Integer> left = preorderTraversal(root.left);        ArrayList<Integer> right = preorderTraversal(root.right);        result.add(root.val);        result.addAll(left);        result.addAll(right);        return result;    }}

public class Solution {    /**     * @param root: The root of binary tree.     * @return: Inorder in ArrayList which contains node values.     */    public ArrayList<Integer> inorderTraversal(TreeNode root) {        ArrayList<Integer> inorder = new ArrayList<Integer>();        if (root == null) {            return inorder;        }        ArrayList<Integer> left = inorderTraversal(root.left);        ArrayList<Integer> right = inorderTraversal(root.right);        inorder.add(root.val);        inorder.addAll(0,left);        inorder.addAll(right);        return inorder;    }}

public class Solution {    /**     * @param root: The root of binary tree.     * @return: Postorder in ArrayList which contains node values.     */    public ArrayList<Integer> postorderTraversal(TreeNode root) {        ArrayList<Integer> postorder = new ArrayList<>();        if (root == null) {            return postorder;        }        ArrayList<Integer> left = postorderTraversal(root.left);        ArrayList<Integer> right = postorderTraversal(root.right);        postorder.add(root.val);        postorder.addAll(0,right);        postorder.addAll(0,left);        return postorder;    }}

Non-Recursion

public class Solution {    /**     * @param root: The root of binary tree.     * @return: Preorder in ArrayList which contains node values.     */    public ArrayList<Integer> preorderTraversal(TreeNode root) {        ArrayList<Integer> preorder = new ArrayList<Integer>();        Stack<TreeNode> stack = new Stack<>();        if (root == null) {            return preorder;        }        stack.push(root);        while (!stack.isEmpty()) {            TreeNode node = stack.pop();            preorder.add(node.val);            if (node.right != null) {                stack.push(node.right);            }            if (node.left != null) {                stack.push(node.left);            }        }        return preorder;    }}

public class Solution {    /**     * @param root: The root of binary tree.     * @return: Inorder in ArrayList which contains node values.     */    public ArrayList<Integer> inorderTraversal(TreeNode root) {        ArrayList<Integer> inorder = new ArrayList<>();        Stack<TreeNode> stack = new Stack<>();        TreeNode node = root;        while (node != null || !stack.isEmpty()) {            while (node != null) {                stack.push(node);                node = node.left;            }            node = stack.pop();            inorder.add(node.val);            node = node.right;        }        return inorder;    }}

public class Solution {    /**     * @param root: The root of binary tree.     * @return: Postorder in ArrayList which contains node values.     */    public ArrayList<Integer> postorderTraversal(TreeNode root) {        ArrayList<Integer> postorder = new ArrayList<>();        Stack<TreeNode> stack = new Stack<>();        if (root == null) {            return postorder;        }        stack.push(root);        while (!stack.isEmpty()) {            TreeNode node = stack.pop();            postorder.add(0,node.val);            if (node.left != null) {                stack.push(node.left);            }            if (node.right != null) {                stack.push(node.right);            }        }        return postorder;    }}