leetcode 二叉树的锯齿形层次遍历 (java实现)

  这道题的思路是层次遍历，并借助于辅助队列，设置标志位进行正向输出或者逆向输出，其中的 layerRes = new ArrayList<>() 这句，我原来写成 layerRes.clear() ，本意是想把 layerRes 的元素清空，好放入下一层，可是发现报错，经过调试发现，因为 res 已经将 layerRes 添加进去，若将 layerRes 清空，则 res 中对应的内容也就会清空，所以应该在内存中 new 新的对象。

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<Integer> layerRes = new ArrayList<>();
        List<List<Integer>> res = new ArrayList<>();
        LinkedList<TreeNode> layer = new LinkedList<>();
        LinkedList<TreeNode> buff = new LinkedList<>();
        int flag = 0;
        if (root == null) return res;
        layer.add(root);
        while (!layer.isEmpty()) {
            TreeNode tn = null;
            tn = layer.removeLast();
            if (tn != null) {
                layerRes.add(tn.val);
            }
            if (flag % 2 == 1) {
                if (tn.right != null) {
                    buff.add(tn.right);
                }
                if (tn.left != null) {
                    buff.add(tn.left);
                }
            }
            else {
                if (tn.left != null) {
                    buff.add(tn.left);
                }
                if (tn.right != null) {
                    buff.add(tn.right);
                }
            }

            if (!buff.isEmpty() && layer.isEmpty()) {
                layer.addAll(buff);
                res.add(layerRes);
                flag += 1;
                layerRes = new ArrayList<>();
                buff.clear();
            }
        }
        if (!layerRes.isEmpty()) {
            res.add(layerRes);
        }
        return res;
    }
}

  以下是别人最快的实现：

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        traverse(root, result, 0);
        return result;
    }

    public void traverse(TreeNode root, List<List<Integer>> result, int level) {
        if (root != null) {
            LinkedList<Integer> list;
            if (result.size() <= level) {
                list = new LinkedList<Integer>();
                result.add(list);
            } else {
                list = (LinkedList<Integer>)result.get(level);
            }

           if (level % 2 == 0) {
              list.addLast(root.val);
           } else {
              list.addFirst(root.val);
           }           
           traverse(root.left, result, level + 1);
           traverse(root.right, result, level + 1);
        }
    }
}