链接

https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/
难度： #中等

题目

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [20,9],
  [15,7]
] 

提示：
节点总数 <= 1000

代码框架

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

    }
}

题目解析

解答思路1：
递归函数方法，
按照元素所在的层，
加入到返回结果的集合中，
最后对返回结果的奇数层进行反转处理厂，
层数从0开始。

解答思路2：
递归函数解法，
按照元素层数加入到返回结果的集合中，
使用LinkedList数据结构，
元素层数为偶数，则加入到list尾部，
元素层数为奇数，则加入到list头部。

解答思路3：
使用一个辅助队列，
队列不为空时，
保存当前队列的数量，
这些元素都属于同一层，
然后遍历这些元素，
加入到返回结果对应的集合中，
注意加入集合List的操作，
如果是偶数层，则加入到集合头部，
如果是奇数层，则加入到集合尾部，
同时把不为空的左右节点加入队列

测试用例

解答1 推荐

package edu.yuwen.sowrd.num32_III.sol1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import edu.yuwen.sowrd.entity.TreeNode;

public class Solution {
    List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) {
            return res;
        }

        // 从上到下，从左到右按层排列
        recurve(root, 0);

        // 结果集小于1行，无需反转
        if (res.size() < 1) {
            return res;
        }

        // 对奇数行进行反转
        for (int i = 1; i < res.size(); i = i + 2) {
            Collections.reverse(res.get(i));
        }

        return res;
    }

    private void recurve(TreeNode node, int k) {

        // 初始化每一层
        if (k > res.size() - 1) {
            res.add(new ArrayList<>());
        }

        List<Integer> level = res.get(k);
        level.add(node.val);

        if (node.left != null) {
            recurve(node.left, k + 1);
        }

        if (node.right != null) {
            recurve(node.right, k + 1);
        }

    }
}

解答2

package edu.yuwen.sowrd.num32_III.sol2;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import edu.yuwen.sowrd.entity.TreeNode;

public class Solution {
    List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) {
            return res;
        }

        recurve(root, 0);

        return res;
    }

    private void recurve(TreeNode node, int k) {
        if (k > res.size() - 1) {
            res.add(new LinkedList<>());
        }

        LinkedList<Integer> list = (LinkedList<Integer>) res.get(k);
        // 偶数层从左到右打印
        if (k % 2 == 0) {
            list.addLast(node.val);
        }
        // 奇数层从右到左打印
        else {
            list.addFirst(node.val);
        }

        if (node.left != null) {
            recurve(node.left, k + 1);
        }

        if (node.right != null) {
            recurve(node.right, k + 1);
        }
    }
}

解答3

package edu.yuwen.sowrd.num32_III.sol3;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

import edu.yuwen.sowrd.entity.TreeNode;

public class Solution {

    List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) {
            return res;
        }

        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);

        while (!q.isEmpty()) {
            // 当前层元素数量
            int size = q.size();
            List<Integer> level = new ArrayList<>(size);
            // 根据当前的层数，决定数据是否加入到队尾
            boolean addLast = res.size() % 2 == 0;
            /**
             * 此处代码可以优化，放到while循环外面，第0层是偶数，为true
             * boolean isEven=true;
             * 然后每次while循环，奇偶数是交替出现的，所以直接取反即可：
             * isEven = !isEven;
             */
            for (int i = size; i > 0; i--) {
                TreeNode node = q.poll();
                // 偶数层加入到队尾
                if (addLast) {
                    level.add(node.val);
                }
                // 奇数层加入到队头
                else {
                    level.add(0, node.val);
                }

                if (node.left != null) {
                    q.offer(node.left);
                }

                if (node.right != null) {
                    q.offer(node.right);
                }
            }
            res.add(level);
        }

        return res;
    }

}