LeetCode Binary Tree Zigzag Level Order Traversal

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

这道题是BFS的变形，与Binary Tree Level Order Traversal相似。但是要求偶数行从左到右，奇数行从右到左。

其实还是BFS, 只不过需要添加一个flag来表明是否需要reverse, 这里用boolean reverse 表示.

需要reverse时，用Collections.reverse(item), 将item反转过来，再加到res中，不要忘记更替reverse的值。

Time Complexity: O(n*logn). reverse用时O(n), 一共有logn/2 层需要reverse. n是树的节点总数. logn 是总层数.

Space: O(n). que最多有n/2个节点。

AC Java:

/**
* 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>> res = new ArrayList<List<Integer>>();
if(root == null){
return res;
}

LinkedList<TreeNode> que = new LinkedList<TreeNode>();
que.add(root);
int curCount = 1;
int nextCount = 0;
List<Integer> item = new ArrayList<Integer>();
boolean reverse = false;

while(!que.isEmpty()){
TreeNode tn = que.poll();
item.add(tn.val);
curCount--;

if(tn.left != null){
que.add(tn.left);
nextCount++;
}
if(tn.right != null){
que.add(tn.right);
nextCount++;
}

if(curCount == 0){
curCount = nextCount;
nextCount = 0;
if(reverse){
Collections.reverse(item);
reverse = false;
}else{
reverse = true;
}
res.add(new ArrayList<Integer>(item));
item = new ArrayList<Integer>();
}
}
return res;
}
}

/**
* 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>> res = new ArrayList<List<Integer>>();
if(root == null){
return res;
}
List<Integer> ls = new ArrayList<Integer>();
Stack<TreeNode> stk = new Stack<TreeNode>();
stk.push(root);
ls.add(root.val);
res.add(ls);
int level = 1;
while(!stk.empty()){
Stack<TreeNode> newStk = new Stack<TreeNode>();
ls = new ArrayList<Integer>();

while(!stk.empty()){
TreeNode tn = stk.pop();
if(level%2 == 0){
if(tn.left != null){
ls.add(tn.left.val);
newStk.push(tn.left);
}
if(tn.right != null){
ls.add(tn.right.val);
newStk.push(tn.right);
}
}else{
if(tn.right != null){
ls.add(tn.right.val);
newStk.push(tn.right);
}
if(tn.left != null){
ls.add(tn.left.val);
newStk.push(tn.left);
}
}
}
level++;
if(ls.size()>0){ //error
res.add(ls);
}
stk = newStk;
}
return res;
}
}