Leetcode-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,#,#,15,7}

,

3
/ \
9  20
/  \
15   7

return its zigzag level order traversal as:

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

confused what

"{1,#,2,3}"

means? > read more on how binary tree is serialized on OJ.

Solution:

/**
* Definition for binary tree
* 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<List<TreeNode>> nodeSet = new ArrayList<List<TreeNode>>();
List<TreeNode> oneLevel = new ArrayList<TreeNode>();
nodeSet.add(oneLevel);
oneLevel.add(root);
boolean left = false;
int index = 0;
while (index<nodeSet.size()){
List<TreeNode> curLevel = nodeSet.get(index);
oneLevel = new ArrayList<TreeNode>();
for (int i=curLevel.size()-1;i>=0;i--){
TreeNode curNode = curLevel.get(i);
if (left){
if (curNode.left!=null) oneLevel.add(curNode.left);
if (curNode.right!=null)oneLevel.add(curNode.right);
} else {
if (curNode.right!=null) oneLevel.add(curNode.right);
if (curNode.left!=null) oneLevel.add(curNode.left);
}
}
if (oneLevel.size()>0) nodeSet.add(oneLevel);
left = !left;
index++;
}

for (int i=0;i<nodeSet.size();i++){
oneLevel = nodeSet.get(i);
List<Integer> oneRes = new ArrayList<Integer>();
for (int j=0;j<oneLevel.size();j++)
oneRes.add(oneLevel.get(j).val);
res.add(oneRes);
}

return res;
}
}

Solution 2:

We actually only need to store the nodes in the current level.

/**
* Definition for binary tree
* 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>> resList = new ArrayList<List<Integer>>();
if (root==null) return resList;
//root level,
List<Integer> oneLevel = new ArrayList<Integer>();
List<TreeNode> nodeList = new ArrayList<TreeNode>();
oneLevel.add(root.val);
resList.add(oneLevel);
nodeList.add(root);
boolean negOrder = true;
while (nodeList.size()>0){
List<TreeNode> nextNode = new ArrayList<TreeNode>();
//Visit the next level.
for (int i=nodeList.size()-1;i>=0;i--){
TreeNode cur = nodeList.get(i);
if (negOrder){
if (cur.right!=null) nextNode.add(cur.right);
if (cur.left!=null) nextNode.add(cur.left);
} else {
if (cur.left!=null) nextNode.add(cur.left);
if (cur.right!=null) nextNode.add(cur.right);
}
}

//If there are nodes in the next level, then put their value into results.
if (nextNode.size()>0){
oneLevel = new ArrayList<Integer>();
for (int i=0;i<nextNode.size();i++) oneLevel.add(nextNode.get(i).val);
resList.add(oneLevel);
}

nodeList = nextNode;
negOrder = !negOrder;
}

return resList;

}
}