链接
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;
}
}
