剑指 Offer 32 - II. 从上到下打印二叉树 II Z字打印

题目：

剑指 Offer 32 - II. 从上到下打印二叉树 II Z字打印
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如:
给定二叉树: [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其层次遍历结果：
[
[3],
[20,9],
[15,7]
]
提示：
节点总数 <= 1000
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof

解题：

关键点：层次遍历，奇数层和偶数层相反的输出顺序；

笨拙的解题方式：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
思路：
从上到下打印，即层次遍历树；区别在于Z字形。
正常层次遍历(从左到右)通常用队列queue容器存储，最后顺序输出；
Z字形，分奇偶层处理，
从右到左的用个临时的栈，正行放入栈之后，在循环弹出放入到queue里面。
*/
class Solution {

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        int leftRightFlag = 0;
        while (!queue.isEmpty()) {
            LinkedList<Integer> queueValue = new LinkedList<>();
            LinkedList<Integer> stackValue = new LinkedList<>();
            for (int i = queue.size(); i > 0; i--) {
                TreeNode tem = queue.poll();
                if (leftRightFlag % 2 == 0) {
                    queueValue.offer(tem.val);
                } else {
                    stackValue.push(tem.val);
                }
                if (tem.left != null) {
                    queue.offer(tem.left);
                }
                if (tem.right != null) {
                    queue.offer(tem.right);
                }
            }

            if (!queueValue.isEmpty()) {
                result.add(queueValue);
            }
            if (!stackValue.isEmpty()) {
                LinkedList<Integer> queueValueTem = new LinkedList<>();
                while (!stackValue.isEmpty()) {
                    queueValueTem.add(stackValue.pop());
                }
                result.add(queueValueTem);
            }

            leftRightFlag = leftRightFlag + 1;
        }
        return result;
    }

}

来自大牛的解题讲解：🐂
题目分析：

方法一：层序遍历 + 双端队列
利用双端队列的两端皆可添加元素的特性，设打印列表（双端队列） tmp ，并规定：

• 奇数层 则添加至 tmp 尾部 ；
• 偶数层 则添加至 tmp 头部 ；

算法流程：

1. 特例处理： 当树的根节点为空，则直接返回空列表 [] ；
2. 初始化： 打印结果空列表 res ，包含根节点的双端队列 deque ；
3. BFS 循环： 当 deque 为空时跳出；
   1. 新建列表 tmp ，用于临时存储当前层打印结果；
   2. 当前层打印循环： 循环次数为当前层节点数（即 deque 长度）；
      1. 出队： 队首元素出队，记为 node；
      2. 打印： 若为奇数层，将 node.val 添加至 tmp 尾部；否则，添加至 tmp 头部；
      3. 添加子节点： 若 node 的左（右）子节点不为空，则加入 deque ；
4. 将当前层结果 tmp 转化为 list 并添加入 res ；
5. 返回值： 返回打印结果列表 res 即可；

复杂度分析：

• 时间复杂度 O(N)O(N) ： NN 为二叉树的节点数量，即 BFS 需循环 NN 次，占用 O(N)O(N) ；双端队列的队首和队尾的添加和删除操作的时间复杂度均为 O(1)O(1) 。
• 空间复杂度 O(N)O(N) ： 最差情况下，即当树为满二叉树时，最多有 N/2N/2 个树节点 同时 在 deque 中，使用 O(N)O(N) 大小的额外空间。

解题：

  /*
        层序遍历 + 双端队列
     */
    public static List<List<Integer>> levelOrder_v1(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if (root != null) {
            queue.add(root);
        }
        while (!queue.isEmpty()) {
            LinkedList<Integer> tmp = new LinkedList<>(); // 双端队列
            for (int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                if (res.size() % 2 == 0) {
                    tmp.addLast(node.val); // 偶数层 -> 队列头部
                } else {
                    tmp.addFirst(node.val); // 奇数层 -> 队列尾部
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            res.add(tmp);
        }
        return res;
    }