Leetcode BST Inorder Traverse

Given a binary tree, return the inorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [1,3,2].

Note: Recursive solution is trivial, could you do it iteratively?

Binary Search Tree:

• The left subtree of a node contains only nodes with keys less than the node's key.
• The right subtree of a node contains only nodes with keys greater than the node's key.
• The left and right subtree each must also be a binary search tree.
• Each node can have up to two successor nodes.
• There must be no duplicate nodes.
• A unique path exists from the root to every other node.  

• 
  
• In-order (symmetric)[edit]

1. Traverse the left subtree by recursively calling the in-order function.
2. Display the data part of root element (or current element).
3. Traverse the right subtree by recursively calling the in-order function.

n-order: A, B, C, D, E, F, G, H, I

Recursion Solution:

Time complexityO(n), Space Complexity O(logn)。

public ArrayList<Integer> inorderTraversal(TreeNode root) {  
    ArrayList<Integer> res = new ArrayList<Integer>();  
    helper(root, res);  
    return res;  
}  
private void helper(TreeNode root, ArrayList<Integer> res)  
{  
    if(root == null)  
        return;  
    helper(root.left,res);  
    res.add(root.val);  
    helper(root.right,res);  
}  

Iteration Solution:

public ArrayList<Integer> inorderTraversal(TreeNode root) {  
    ArrayList<Integer> res = new ArrayList<Integer>();  
    LinkedList<TreeNode> stack = new LinkedList<TreeNode>();  
    while(root!=null || !stack.isEmpty())  
    {  
        if(root!=null)  
        {  
            stack.push(root);  
            root = root.left;  
        }  
        else  
        {  
            root = stack.pop();  
            res.add(root.val);  
            root = root.right;  
        }  
    }  
    return res;  
}