Leetcode Binary Tree Zigzag level Order Traversal

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree {3,9,20,#,#,15,7},
    3
   / 
  9  20
    /  
   15   7
return its zigzag level order traversal as:
[
  [3],
  [20,9],
  [15,7]
]

参考这道题其实还是树的层序遍历Binary Tree Level Order Traversal。不过这里稍微做了一点变体。在Binary Tree Level Order Traversal中我们是维护了一个队列来完成遍历，而在这里为了使每次都倒序出来，我们很容易想到用栈的结构来完成这个操作。有一个区别是这里我们需要一层一层的来处理（原来可以按队列插入就可以，因为后进来的元素不会先处理），所以会同时维护新旧两个栈，一个来读取，一个存储下一层结点。总体来说还是一次遍历完成，所以时间复杂度是O(n)，空间复杂度最坏是两层的结点，所以数量级还是O(n)（满二叉树最后一层的结点是n/2个）。代码如下：

第二遍做法：几个设定: Pstack为父亲节点这一层的node集合，Cstack用来存子节点这一层的node；root节点一层为第0层; 节点在出栈的时候加入List; 偶数层先加左child再加右child进入Child Stack中，这样pop出来的时候是先右child再左child；奇数层先加右child再加左child。需要注意的是15-16行的 != Null 条件很必要，否则栈里面会有null， 这样栈也不为空。循环继续执行，但是null元素到第13行.val就会出错

public class Solution {
    public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (root == null) return res;
        LinkedList<TreeNode> Pstack = new LinkedList<TreeNode>();
        LinkedList<TreeNode> Cstack = new LinkedList<TreeNode>();
        Pstack.push(root);
        int level = 0;
        while (!Pstack.isEmpty()) {
            ArrayList<Integer> item = new ArrayList<Integer>();
            while (!Pstack.isEmpty()) {
                root = Pstack.pop();
                item.add(root.val);
                if (level % 2 == 0) {
                    if (root.left != null) Cstack.push(root.left);
                    if (root.right != null) Cstack.push(root.right);
                }
                else {
                    if (root.right != null) Cstack.push(root.right);
                    if (root.left != null) Cstack.push(root.left);
                }
            }
            res.add(new ArrayList<Integer>(item));
            Pstack = Cstack;
            Cstack = new LinkedList<TreeNode>();
            level++;
        }
        return res;
    }

 贴一个DFS做法：很好

1. O(n) solution by using LinkedList along with ArrayList. So insertion in the inner list and outer list are both O(1),
2. Using DFS and creating new lists when needed.

public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) 
    {
        List<List<Integer>> sol = new ArrayList<>();
        travel(root, sol, 0);
        return sol;
    }
    
    private void travel(TreeNode curr, List<List<Integer>> sol, int level)
    {
        if(curr == null) return;
        
        if(sol.size() <= level)
        {
            List<Integer> newLevel = new LinkedList<>();
            sol.add(newLevel);
        }
        
        List<Integer> collection  = sol.get(level);
        if(level % 2 == 0) collection.add(curr.val);
        else collection.add(0, curr.val);
        
        travel(curr.left, sol, level + 1);
        travel(curr.right, sol, level + 1);
    }
}