个人记录-LeetCode 103. Binary Tree Zigzag Level Order Traversal

问题：
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).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its zigzag level order traversal as:

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

这个问题要求以回文的方式，
输出每一层节点的值。

主要思路与LeetCode 102一样，
我们依然用List保存当前层的TreeNode，
然后根据List中的TreeNode，获取它们的子节点。

与LeetCode 102不同的是，我们每次都以逆序的方式，
从保存TreeNode的List中取出下一层的字节点。

这么做的依据是：
上一层先输出的节点，将优先被加入到List中；
现在要求其下一层字节点后输出，因此只需要后从List取出即可。
此外，需要用标志位记录每次应该先取左子节点，还是取右节点。

代码实例：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        //保存最后的结果
        List<List<Integer>> rst = new ArrayList<>();

        if (root != null) {
            List<Integer> valueList = new ArrayList<>();
            valueList.add(root.val);

            List<TreeNode> nodeList = new ArrayList<>();
            nodeList.add(root);

            rst.add(valueList);

            //递归调用
            //参数true表示，先左后右
            //参数false表示，先右后左
            innerHelper(rst, nodeList, false);
        }

        return rst;
    }

    private void innerHelper(List<List<Integer>> rst, List<TreeNode> nodeList, boolean positiveOrder) {
        if (nodeList != null && nodeList.size() > 0) {
            List<Integer> valueList = new ArrayList<>();
            List<TreeNode> nextNodeList = new ArrayList<>();

            //逆序取出上一层的节点
            for (int i = nodeList.size() - 1; i >= 0; --i) {
                TreeNode node = nodeList.get(i);

                //根据positiveOrder决定先左后右，还是先右后左
                TreeNode first = positiveOrder ? node.left : node.right;
                TreeNode second = positiveOrder ? node.right : node.left;

                //将值和节点分别加入到List中
                if (first != null) {
                    valueList.add(first.val);
                    nextNodeList.add(first);
                }

                if (second != null) {
                    valueList.add(second.val);
                    nextNodeList.add(second);
                }
            }

            if (nextNodeList.size() > 0) {
                rst.add(valueList);

                //继续递归，反向positiveOrder的值
                innerHelper(rst, nextNodeList, !positiveOrder);
            }
        }
    }
}