Fair Binary Tree Zigzag Level Order TraversalMy Submissions
29%
Accepted
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).
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]
]
SOLUTION 1. When add the nodes to level, alternate the direction. USE ONE QUEUE
The first level contains only the root node. The direction is from left to right, that is add at last.
The next level is from right to left, add at first.
<span style="color:#717171;">/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of binary tree.
* @return: A list of lists of integer include
* the zigzag level order traversal of its nodes' values
*/
public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
if(root == null) {
return rst;
}
ArrayList<Integer> level = new ArrayList();
Queue<TreeNode> q = new LinkedList();
q.add(root);
int direction = 0;
</span><span style="color:#ff6666;"> //direction % 2 ==0 add last;
//else add first</span><span style="color:#717171;">
while(!q.isEmpty()) {
int size = q.size();
for(int i = 0; i < size; i++) {
TreeNode temp = q.poll();
</span><span style="color:#ff6666;">if(direction % 2 == 0) {
level.add(temp.val);
} else {
level.add(0, temp.val);
}</span><span style="color:#717171;">
if(temp.left != null) {
q.add(temp.left);
}
if(temp.right != null) {
q.add(temp.right);
}
}
rst.add(new ArrayList(level));
level = new ArrayList<Integer>();
direction++;
}
return rst;
}
}
</span>
2. USE TWO STACKS
NORMAL ORDER: push left, push right
!NORMAL ORDER: push right, push left
alternate between normal and !normal order
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of binary tree.
* @return: A list of lists of integer include
* the zigzag level order traversal of its nodes' values
*/
public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
if(root == null) {
return rst;
}
ArrayList<Integer> level = new ArrayList();
<span style="color:#ff0000;">Stack<TreeNode> cur = new Stack();
Stack<TreeNode> next = new Stack();</span>
cur.add(root);
<span style="color:#ff0000;">boolean normalOrder = true;</span>
while(!cur.isEmpty()) {
while(!cur.isEmpty()) {
TreeNode temp = cur.pop();
level.add(temp.val);
<span style="color:#ff0000;"> if(normalOrder) {
if(temp.left != null) {
next.push(temp.left);
}
if(temp.right != null) {
next.push(temp.right);
}
} else {
if(temp.right != null) {
next.push(temp.right);
}
if(temp.left != null) {
next.push(temp.left);
}
}</span>
}
rst.add(new ArrayList(level));
level = new ArrayList<Integer>();
cur = next;
next = new Stack<TreeNode>();
<span style="color:#ff0000;"> normalOrder = !normalOrder;</span>
}
return rst;
}
}
Fair Binary Tree Zigzag Level Order TraversalMy Submissions
29%
Accepted
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).
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]
]
SOLUTION 1. When add the nodes to level, alternate the direction. USE ONE QUEUE
The first level contains only the root node. The direction is from left to right, that is add at last.
The next level is from right to left, add at first.
<span style="color:#717171;">/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of binary tree.
* @return: A list of lists of integer include
* the zigzag level order traversal of its nodes' values
*/
public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
if(root == null) {
return rst;
}
ArrayList<Integer> level = new ArrayList();
Queue<TreeNode> q = new LinkedList();
q.add(root);
int direction = 0;
</span><span style="color:#ff6666;"> //direction % 2 ==0 add last;
//else add first</span><span style="color:#717171;">
while(!q.isEmpty()) {
int size = q.size();
for(int i = 0; i < size; i++) {
TreeNode temp = q.poll();
</span><span style="color:#ff6666;">if(direction % 2 == 0) {
level.add(temp.val);
} else {
level.add(0, temp.val);
}</span><span style="color:#717171;">
if(temp.left != null) {
q.add(temp.left);
}
if(temp.right != null) {
q.add(temp.right);
}
}
rst.add(new ArrayList(level));
level = new ArrayList<Integer>();
direction++;
}
return rst;
}
}
</span>
2. USE TWO STACKS
NORMAL ORDER: push left, push right
!NORMAL ORDER: push right, push left
alternate between normal and !normal order
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of binary tree.
* @return: A list of lists of integer include
* the zigzag level order traversal of its nodes' values
*/
public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
if(root == null) {
return rst;
}
ArrayList<Integer> level = new ArrayList();
<span style="color:#ff0000;">Stack<TreeNode> cur = new Stack();
Stack<TreeNode> next = new Stack();</span>
cur.add(root);
<span style="color:#ff0000;">boolean normalOrder = true;</span>
while(!cur.isEmpty()) {
while(!cur.isEmpty()) {
TreeNode temp = cur.pop();
level.add(temp.val);
<span style="color:#ff0000;"> if(normalOrder) {
if(temp.left != null) {
next.push(temp.left);
}
if(temp.right != null) {
next.push(temp.right);
}
} else {
if(temp.right != null) {
next.push(temp.right);
}
if(temp.left != null) {
next.push(temp.left);
}
}</span>
}
rst.add(new ArrayList(level));
level = new ArrayList<Integer>();
cur = next;
next = new Stack<TreeNode>();
<span style="color:#ff0000;"> normalOrder = !normalOrder;</span>
}
return rst;
}
}
Fair Binary Tree Zigzag Level Order TraversalMy Submissions
29%
Accepted
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).
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]
]
SOLUTION 1. When add the nodes to level, alternate the direction. USE ONE QUEUE
Fair Binary Tree Zigzag Level Order TraversalMy Submissions
29%
Accepted
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).
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] ]
The first level contains only the root node. The direction is from left to right, that is add at last.
The next level is from right to left, add at first.
<span style="color:#717171;">/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of binary tree.
* @return: A list of lists of integer include
* the zigzag level order traversal of its nodes' values
*/
public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
if(root == null) {
return rst;
}
ArrayList<Integer> level = new ArrayList();
Queue<TreeNode> q = new LinkedList();
q.add(root);
int direction = 0;
</span><span style="color:#ff6666;"> //direction % 2 ==0 add last;
//else add first</span><span style="color:#717171;">
while(!q.isEmpty()) {
int size = q.size();
for(int i = 0; i < size; i++) {
TreeNode temp = q.poll();
</span><span style="color:#ff6666;">if(direction % 2 == 0) {
level.add(temp.val);
} else {
level.add(0, temp.val);
}</span><span style="color:#717171;">
if(temp.left != null) {
q.add(temp.left);
}
if(temp.right != null) {
q.add(temp.right);
}
}
rst.add(new ArrayList(level));
level = new ArrayList<Integer>();
direction++;
}
return rst;
}
}
</span>
2. USE TWO STACKS
NORMAL ORDER: push left, push right
!NORMAL ORDER: push right, push left
alternate between normal and !normal order
/**
* Definition of TreeNode:
* public class TreeNode {
* public int val;
* public TreeNode left, right;
* public TreeNode(int val) {
* this.val = val;
* this.left = this.right = null;
* }
* }
*/
public class Solution {
/**
* @param root: The root of binary tree.
* @return: A list of lists of integer include
* the zigzag level order traversal of its nodes' values
*/
public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
if(root == null) {
return rst;
}
ArrayList<Integer> level = new ArrayList();
<span style="color:#ff0000;">Stack<TreeNode> cur = new Stack();
Stack<TreeNode> next = new Stack();</span>
cur.add(root);
<span style="color:#ff0000;">boolean normalOrder = true;</span>
while(!cur.isEmpty()) {
while(!cur.isEmpty()) {
TreeNode temp = cur.pop();
level.add(temp.val);
<span style="color:#ff0000;"> if(normalOrder) {
if(temp.left != null) {
next.push(temp.left);
}
if(temp.right != null) {
next.push(temp.right);
}
} else {
if(temp.right != null) {
next.push(temp.right);
}
if(temp.left != null) {
next.push(temp.left);
}
}</span>
}
rst.add(new ArrayList(level));
level = new ArrayList<Integer>();
cur = next;
next = new Stack<TreeNode>();
<span style="color:#ff0000;"> normalOrder = !normalOrder;</span>
}
return rst;
}
}