[LeetCode] 103. Binary Tree Zigzag Level Order Traversal

原题链接：https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/

1. 题目介绍

Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).
给出一个二叉树，返回Z字形曲折遍历的结果。比如，在树的第一层是从左向右遍历，那么在第二层就要从右向左遍历。第三层又变为从左向右遍历。

For example:
Given binary tree [3,9,20,null,null,15,7],
给出二叉树 [3,9,20,null,null,15,7]，

return its zigzag level order traversal as:
返回其Z字形遍历的路径：

2. 解题思路

本题和 102. Binary Tree Level Order Traversal 非常类似，102题是将二叉树逐层遍历，而本题是逐层Z字形遍历。因此只需要将偶数层的遍历结果反转就可以了。

方法1 BFS + 计数法

首先有一个规律：遍历完一层以后，队列中节点的个数就是二叉树下一层的节点数。

一开始，队列中只有3，队列的长度是1，第一层也只有1个节点。
接下来将3移出队列，将3的左右子节点放入队列。

于是，现在队列中有9和20，队列的长度是2，第二层也只有2个节点。
接下来分别将9、20移出队列，左右子节点放入队列。如果左右子节点为空，就不放入队列。

现在，队列中有15、7，队列长度为2，第3层也只有2个节点。

因此可以按照上面的操作方式，对树进行分层，进而将同一层的节点val值都放入一个list里面，然后一起并入总的List< List< Integer>>里面去。

实现代码

/**
 * 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>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        if(root == null){
            return ans;
        }
        
        Queue<TreeNode> que = new LinkedList<>();
        que.add(root);//为队列中添加根节点
        
        int Count = 1;//记录层数，如果是偶数层，需要对list进行反转
        while(que.isEmpty() == false){
            int n = que.size();//在开始阶段，队列中存放了当前层的所有节点
            List<Integer> res = new ArrayList<>();
            for(int i = 0; i<n ;i++){
                //遍历当前层的每一个节点，将其val值放入res，左右子节点放入队列
                TreeNode temp = que.remove();
                res.add(temp.val);
                
                if(temp.left != null){
                    que.add(temp.left);
                }
                if(temp.right != null){
                    que.add(temp.right);
                }
            }
            
            //如果是偶数层，需要对list进行反转
            if(Count % 2 == 0){
                Collections.reverse(res);
            }
            ans.add(res);
            Count++;
        }   
        return ans;
    }
}

方法2 DFS

可以使用深度优先搜索来解决。
需要设定一个层数level作为dfs函数的参数。通过level值对树进行分层。

/**
 * 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>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        if(root == null){
            return ans;
        }
        dfs(root, 1, ans);
        return ans;
    }
    public void dfs(TreeNode node, int level, List<List<Integer>> ans ){
        if(node == null){
            return;
        }

        if(level > ans.size()){
            ans.add(new ArrayList<Integer>());
        }
        if(level % 2 == 0){
            ans.get(level-1).add(0,node.val);
        }else{
            ans.get(level-1).add(node.val);
        }
        
        dfs(node.left , level+1 ,ans);
        dfs(node.right, level+1 ,ans);    
    }
}

3. 参考材料

https://blog.csdn.net/Bertram03/article/details/90319770