给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
    例如：
    给定二叉树 [3,9,20,null,null,15,7],

    3
    / \
    9 20
    / \
    15 7

    返回锯齿形层序遍历如下：

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

    1. public class TreeNode {
    2.      int val;
    3.     TreeNode left;
    4.     TreeNode right;
    5.     TreeNode () {}
    6.     TreeNode (int val) {this.val = val}
    7.     TreeNode (int val, TreeNode left, TreeNode right) {
    8.          this.val = val;
    9.         this.left = left;
    10.         this.right = right;   
    11.     }
    12. }
    14. class Solution {
    15.     public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
    16.         List<List<Integer>> res = new ArrayList<>();
    17.         if (root == null)
    18.             return res;
    19.         Queue<TreeNode> queue = new LinkedList<>();
    20.         queue.add(root);
    21.         boolean leftToRight = true;//从左到右
    22.         while (!queue.isEmpty()) {
    23.             List<Integer> list = new ArrayList<>();
    24.             int n = queue.size();
    25.             for (int i = 0; i < n; i++) {
    26.                 TreeNode node = queue.poll();
    27.                 if (leftToRight == true) {
    28.                     list.add(node.val);//如果从左到右的顺序就正着插入 list
    29.                 } else {
    30.                     list.add(0, node.val);// 否则就按照倒序插入 list
    31.                 }
    32.                 if (node.left != null) {
    33.                     queue.add(node.left);
    34.                 }
    35.                 if (node.right != null) {
    36.                     queue.add(node.right);
    37.                 }
    38.             }
    39.             leftToRight = !leftToRight;
    40.             res.add(list);
    41.         }
    42.         return res;
    43.     }
    44. }

    来源：力扣（LeetCode）
    链接：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal
    image.png