Binary Tree Traversal

1. Preorder Tree Traversal

// Solution 1. With Stack
// Time Complexity : O(n)
// Space Complexity: O(h) ~ O(log n)
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) return list;
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        TreeNode cur = null;
        while (!stack.isEmpty()) {
            cur = stack.pop();
            list.add(cur.val); // Do manipulation here
            if (cur.right != null) stack.push(cur.right);
            if (cur.left != null) stack.push(cur.left);
        }
        
        return list;
    }
}

// Solution 2. Morris Traversal
// Time Complexity : O(n)
// Space Complexity : O(1)
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        
        TreeNode cur = root;
        TreeNode pre = null;
        while (cur != null) {
            if (cur.left != null) {
                pre = cur.left;
                while (pre.right != null && pre.right != cur) { // link / unlink
                    pre = pre.right;
                }
                if (pre.right == null) {
                    list.add(cur.val);
                    pre.right = cur;
                    cur = cur.left;
                } else {
                    pre.right = null;
                    cur = cur.right;
                }
            } else {
                list.add(cur.val);
                cur = cur.right;
            }
        }
        
        return list;
    }
}

2. Inorder Tree Traversal

// Solution 1. With Stack
// Time Complexity : O(n)
// Space Complexity: O(h) ~ O(log n)
public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) return list;
        
        TreeNode cur = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                list.add(cur.val); // Do manipulation here
                cur = cur.right;
            }
        }
        
        return list;
    }
}

// Solution 2. Morris Traversal
// Time Complexity : O(n)
// Space Complexity : O(1)
public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        
        TreeNode cur = root;
        TreeNode pre = null;
        while (cur != null) {
            if (cur.left != null) {
                pre = cur.left;
                while (pre.right != null && pre.right != cur) {
                    pre = pre.right;
                }
                if (pre.right == null) {
                    pre.right = cur;
                    cur = cur.left;
                } else {
                    pre.right = null;
                    list.add(cur.val);
                    cur = cur.right;
                }
            } else {
                list.add(cur.val);
                cur = cur.right;
            }
        }
        return list;
    }
}

3. Postorder Tree Traversal

// Solution 1. With Stack
// Time Complexity : O(n)
// Space Complexity: O(h) ~ O(log n)
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root == null) return list;
        
        TreeNode pre = null;
        TreeNode cur = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                if (cur.right == null || pre == cur.right) { // won't put back
                    list.add(cur.val); // Do manipulation here
                    pre = cur;
                    cur = null;
                } else {
                    stack.push(cur);
                    cur = cur.right;
                }
            }
        }
        
        return list;
    } 
}

// Solution 2. Morris Traversal
// Time Complexity : O(n)
// Space Complexity : O(1)
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        
        TreeNode dump = new TreeNode(-1);
        dump.left = root;
        
        TreeNode cur = dump;
        TreeNode pre = null;
        while (cur != null) {
            if (cur.left != null) {
                pre = cur.left;
                while (pre.right != null && pre.right != cur) {
                    pre = pre.right;
                }
                if (pre.right == null) {
                    pre.right = cur;
                    cur = cur.left;
                } else {
                    List<Integer> rev = new ArrayList<Integer>();
                    TreeNode tmp = cur.left;
                    while (tmp != cur) {
                        rev.add(tmp.val);
                        tmp = tmp.right;
                    }
                    if (!rev.isEmpty()) {
                        Collections.reverse(rev); // Collections.reverse return void
                        list.addAll(rev);
                    }
                    pre.right = null;
                    cur = cur.right;
                } 
            } else {
                    cur = cur.right;
            }
        }
        return list;
    }
}