二叉树的锯齿形层次遍历,lintcode

给出一棵二叉树，返回其节点值的锯齿形层次遍历（先从左往右，下一层再从右往左，层与层之间交替进行）

样例

给出一棵二叉树 {3,9,20,#,#,15,7},

3

/ \

9 20

/ \

15 7

返回其锯齿形的层次遍历为：

[

[3],

[20,9],

[15,7]

]

解题思路：基于之前层次遍历的实现，加一个标记纪录奇偶层，在偶数层逆序将节点加入链表。

一刷ac

/**
* 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>> result = new ArrayList<ArrayList<Integer>>();
if(root == null) return result;
LinkedList<TreeNode> nodelist = new LinkedList<TreeNode>();
boolean order = true;
nodelist.offer(root);
while(!nodelist.isEmpty()){
int size = nodelist.size();
ArrayList<Integer> al = new ArrayList<Integer>();
for(int i = 0; i < size; i++){
TreeNode node = nodelist.poll();
if(order) al.add(node.val);
else al.add(0,node.val);
if(node.left != null) nodelist.offer(node.left);
if(node.right != null) nodelist.offer(node.right);
}
order = !order;
result.add(al);
}
return result;
}
}

用两个栈也是可以做的，分别存储当前层和下一层节点。

/**
* 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;
Stack<TreeNode> curr_layer = new Stack<TreeNode>();
Stack<TreeNode> next_layer = new Stack<TreeNode>();
curr_layer.push(root);
ArrayList<Integer> al = new ArrayList<Integer>();
boolean order = false;
while(!curr_layer.isEmpty()){
TreeNode node = curr_layer.pop();
al.add(node.val);
if(order){
if(node.right != null) next_layer.push(node.right);
if(node.left != null) next_layer.push(node.left);
}else{
if(node.left != null) next_layer.push(node.left);
if(node.right != null) next_layer.push(node.right);
}

if(curr_layer.isEmpty()){
rst.add(al);
curr_layer = next_layer;
next_layer = new Stack<TreeNode>();
al = new ArrayList<Integer>();
order = !order;
}
}

return rst;
}
}