Binary Tree Preorder Traversal

Preorder: first, visit parent node, then, left child, last is to visit right child.

Algorithm 1 -- DFS & Stack

We can use stack to store left child and right child.

public class Solution {
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
         ArrayList<Integer> lst = new ArrayList<Integer>();
 
        if(root == null)
            return lst; 
 
        Stack<TreeNode> stack = new Stack<TreeNode>();
        //define a pointer to track nodes
        TreeNode p = root;
 
        while(!stack.empty() || p != null){
 
            // if it is not null, push to stack
            //and go down the tree to left
            if(p != null){
                lst.add(p.val);
                stack.push(p);
                p = p.left;
            }else{
                TreeNode t = stack.pop();
                p = t.right;
            }
        }
 
        return lst;
    }
}

Algorithm 2 -- Recursive

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