这是我参与11月更文挑战的第14天，活动详情查看：2021最后一次更文挑战

从上到下打印二叉树Ⅲ

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

 

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

3

/ \

9 20

/ \

15 7

返回其层次遍历结果：

[

[3],

[20,9],

[15,7]

]  

提示：节点总数 <= 1000

题解

方法一：层次遍历-双端队列——Java

利用双端队列的两端皆可添加元素的特性，设打印列表（双端队列） tmp ，并规定：

奇数层 则添加至 tmp 尾部 ，

偶数层 则添加至 tmp 头部 。

算法流程：

特例处理： 当树的根节点为空，则直接返回空列表 [] ；

初始化： 打印结果空列表 res ，包含根节点的双端队列 deque ；

BFS 循环： 当 deque 为空时跳出；

新建列表 tmp ，用于临时存储当前层打印结果；

当前层打印循环： 循环次数为当前层节点数（即 deque 长度）；

出队： 队首元素出队，记为 node；

打印： 若为奇数层，将 node.val 添加至 tmp 尾部；否则，添加至 tmp 头部；

添加子节点： 若 node 的左（右）子节点不为空，则加入 deque ；

将当前层结果 tmp 转化为 list 并添加入 res ；

返回值： 返回打印结果列表 res 即可；

class Solution {
    public List<List<Integer>> levelOrder(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;
    }
}

时间复杂度：O（N）

空间复杂度：O（N）

方法二：BFS-逆序数组——Go

func levelOrder(root *TreeNode) [][]int {
    res := [][]int{}
    if root == nil {
        return res
    }
    queue := []*TreeNode{root}
    var Level int = 0
    for len(queue) != 0 {
        //利用临时队列，暂存每个节点的左右子树
        temp := []*TreeNode{}
        //只需考虑在同一层上追加元素
        res = append(res, []int{})
        for _, v := range queue {
            res[Level] = append(res[Level], v.Val)
            if v.Left != nil {
                temp = append(temp, v.Left)
            }
            if v.Right != nil {
                temp = append(temp, v.Right)
            }
        }
        if Level % 2 != 0 {
            Reverse(res[Level])
        }
        //层级加1，队列重新复制为队列的左右子树集
        Level++
        queue = temp
    }
    return res
}


//数组倒序函数
func Reverse(arr []int) {
	var temp int
	length := len(arr)
	for i := 0; i < length/2; i++ {
		temp = arr[i]
		arr[i] = arr[length-1-i]
		arr[length-1-i] = temp
	}
}