[Leetcode] Binary Tree Traversal

Preorder: https://leetcode.com/problems/binary-tree-preorder-traversal/
Inorder: https://leetcode.com/problems/binary-tree-inorder-traversal/
Postorder: https://leetcode.com/problems/binary-tree-postorder-traversal/submissions/
Level order：https://leetcode.com/problems/binary-tree-level-order-traversal/

Preorder:
利用linkedlist存储node，首先存root，根据先进后出，先存right再存left，每次取linkedlist最末尾的node计算

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        LinkedList<Integer> output = new LinkedList<>();
        LinkedList<TreeNode> stack = new LinkedList<>();
        
        if(root == null) {
            return output;
        }
        
        stack.add(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.pollLast();
            output.add(node.val);
            if(node.right != null) {
                stack.add(node.right);
            }
            if(node.left != null) {
                stack.add(node.left);
            }
        }
        return output;
    }
}

Inorder:
Solution1:
利用递归

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        LinkedList<Integer> output = new LinkedList<>();
        helper(root, output);
        return output;
    }
    
    public void helper(TreeNode node, LinkedList output) {
        if(node != null ) {
            if(node.left != null) {
                helper(node.left, output);
            }
            output.add(node.val);
            if(node.right != null) {
                helper(node.right, output);
            }
        }
    }
}

Solution2:
利用stack，先存入root和所有left，再寻找right

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        LinkedList<Integer> output = new LinkedList<>();
        Stack<TreeNode> stack = new Stack();
        
        if(root == null) {
            return output;
        }
        
        TreeNode curr = root;
        while(!stack.isEmpty() || curr != null) {
            while (curr != null) {
                stack.push(curr);
                curr = curr.left;
            }
            curr = stack.pop();
            output.add(curr.val);
            curr = curr.right;
        }
        return output;
    }
}

Postorder:
Solution1:
利用递归

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> output = new LinkedList<>();
        LinkedList<TreeNode> stack = new LinkedList<>();
        
        if (root == null) {
            return output;
        }
        
        stack.add(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.pollLast();
            output.addFirst(node.val); // 不断在前面插入value
            if(node.left != null) {
                stack.add(node.left);
            }
            if(node.right != null) {
                stack.add(node.right);
            }
        }
        return output;
    }
}

Level Order:
Solution:
将level计数，每往下一层level+1

class Solution {
    
    List<List<Integer>> levels = new ArrayList<>();
        
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) {
            return levels;
        }
        helper(root, 0);
        return levels;
    }
    
    public void helper(TreeNode node, int level) {
        if(levels.size() == level) {
            levels.add(new ArrayList<Integer>());
        } 
        
        levels.get(level).add(node.val);
        
        if (node.left != null) {
            helper(node.left, level+1);
        }
        if (node.right != null) {
            helper(node.right, level+1);
        }
    }
}

Solution2:
使用queue

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        if(root == null) {
            return ans;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        
        while(!queue.isEmpty()) {
            ArrayList<Integer> list = new ArrayList<>();
            int size = queue.size();
            
            for(int i = 0; i < size; i++) {
                TreeNode node = queue.poll(); // poll()每次取出的都是队伍首位
                list.add(node.val);
                if(node.left != null) {
                    queue.add(node.left);
                }
                if(node.right != null) {
                    queue.add(node.right);
                }
            }
            ans.add(list);
        }
        return ans;
    }
}