[ACE] PreOrder and InOrder traversal on LeetCode

Binary Tree PreOrder Traversal

We have discussed tree before, but today i found a similar question on LeetCode, i’d like to analysis the question here again.
The question is:
Given a binary tree, return the preorder traversal of its nodes’ values.
For example:
Given binary tree {1,#,2,3},

1
\
2
/
3

return [1,2,3].
Note: Recursive solution is trivial, could you do it iteratively?
My Answer is as follows:
Basic idea: what i do for this question is to store the tree nodes in Stack.
Thus, we need to push the right child first and then left child.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        if(root == null){
            return arrayList;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.empty()){
            TreeNode n = stack.pop();
            arrayList.add(n.val);
            if(n.right != null){
                stack.push(n.right);
            }
            if(n.left != null){
                stack.push(n.left);
            }
        }
        return arrayList;
    }
}

Then LeetCode recommend me to do the above question in InOrder. As we know, if we do it in InOrder, the answer will be [1,3,2]
So How can we solve this question?
Again, it is simple to use recursive:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    List<Integer> result = new ArrayList<Integer>();
    public List<Integer> inorderTraversal(TreeNode root) {
         if(root !=null){
            helper(root);
        }

        return result;
    }

    public void helper(TreeNode p){
        if(p.left!=null)
            helper(p.left);

        result.add(p.val);

        if(p.right!=null)
            helper(p.right);
    }
}

Isn’t it simple?