[LeetCode#144]Binary Tree Preorder Traversal

The problem:

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].

The recursion solution:

public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> ret = new ArrayList<Integer>();
        
        if (root == null)
            return ret;
        
        helper(root, ret);
        return ret;
    }
    
    private void helper(TreeNode cur_root, ArrayList<Integer> ret) {
        
        if (cur_root == null)
            return;
        
        ret.add(cur_root.val);
        helper(cur_root.left, ret);
        helper(cur_root.right, ret);
    }
}

An iteration way:

My analysis:

The iteration way in traversaling a tree is very skillful and important. Even it differs a lot from the iteration methond we have used (usually over an array), we must master it and understand it!
key skills:
1. use a stack properly, cause we need to reuse the node we have already reached in any traversal methods.
2. add the node properly into the final answer set, according to the preorder, inorder or postorder requirement.

The detail in implementation:
1. use a big while loop for the iteration.
1.1 if the current node is not null, we could explore its children.
1.2 if the current node is null, that means we have reached the leaf level. if the stack is not empty, it means we still have some possible right children to explore.
thus, the while loop is:

while (root != null || stack.empty() != true)

2. then we need a "if" statement to distinguish between whether entering the loop is caused by current node is null or not.
2.1 iff the current node is not null, we could push the current node into stack, and then explore the current node's left child.

if (root != null) { //for later usage
    stack.push(root);
    root = root.left;
}

2.2 iff the current node is alreay null, we could retrace to its ancestor nodes by pop a node out from the stack, and then explore the node's right child.

The important facts:
1. once a node is in stack, its right child must have been explored.
2. the stack is used for retracing the scanned root nodes.

My solution:

public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        
        ArrayList<Integer> ret = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        
        while (root != null || stack.empty() != true) {
            
            if (root != null) {
                ret.add(root.val);
                stack.push(root);
                root = root.left;
            } else{
                root = stack.pop();
                root = root.right;
            }
        }
        
        return ret;
    }