103. Binary Tree Zigzag Level Order Traversal

题目描述（中等难度）

和 102 题 类似，二叉树的层次遍历。只不过这题要求，第 1 层从左到右，第 2 层从右到左，第 3 层从左到右，第 4 层从右到左，交替进行。
思路分析
大家可以先做下 102 题 吧，直接在 102 题的基础上进行修改即可。从左到右和从右到左交替，所以我们只需要判断当前的 level，层数从 0 开始的话，偶数就把元素添加到当前层的末尾，奇数的话，每次把新元素添加到头部，这样就实现了从右到左的遍历。

解法一 DFS

判断 level 是偶数还是奇数即可。

import java.util.ArrayList;
import java.util.List;
class TreeNode{
	int val;
	TreeNode left;
	TreeNode right;
	TreeNode(int x){val=x;}
}

public class Binary_Tree_Zigzag_Level_Order_Traversal {
	
	public static List<List<Integer>> levelorder(TreeNode root){
		
		List<List<Integer>>ans=new ArrayList<>();
		DFS(root,0,ans);
		return ans;
	}
	private static void DFS(TreeNode root,int level,List<List<Integer>>ans) {
		if(root==null) return;
		if(ans.size()<=level) {
			ans.add(new ArrayList<>());
		}
		if(level % 2==0) {
			ans.get(level).add(root.val);//添加到末尾
		}else {
			ans.get(level).add(0,root.val);//添加到头部
		}
		DFS(root.left,level+1,ans);
		DFS(root.right,level+1,ans);
	}
	public static void main(String args[]) {
		TreeNode[] node=new TreeNode[5];
		node[0]=new TreeNode(3);
		node[1]=new TreeNode(9);
		node[2]=new TreeNode(20);
		node[3]=new TreeNode(15);
		node[4]=new TreeNode(7);
		node[0].left=node[1];
		node[0].right=node[2];
		node[2].left=node[3];
		node[2].right=node[4];
		
		List<List<Integer>>ans=levelorder(node[0]);
		System.out.println(ans);
	}
}

解法二 BFS 队列

如果是顺序刷题，前边的 97 题， 98 题，101 题，都用到了 BFS ，应该很熟悉了。

之前我们用一个 while 循环，不停的从队列中拿一个节点，并且在循环中将当前取出来的节点的左孩子和右孩子也加入到队列中。

相比于这道题，我们要解决的问题是，怎么知道当前节点的 level 。

定义一个新的 class，class 里边两个成员 node 和 level，将我们新定义的 class 每次加入到队列中。或者用一个新的队列和之前的节点队列同步入队出队，新的队列存储 level。

下边的代码实现后一种，并且对 level 进行判断。
BFS:层次遍历

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Binary_Tree_Zigzag_Level_Order_Traversal2 {
	
	public static List<List<Integer>>levelorder(TreeNode root){
		List<List<Integer>>ans=new ArrayList<>();
		if(root==null) return ans;
		
		Queue<TreeNode>treeNode=new LinkedList<>();
		Queue<Integer>nodeLevel=new LinkedList<>();
		int level=0;
		treeNode.offer(root);//添加元素
		nodeLevel.offer(level);
		
		while(!treeNode.isEmpty()) {
			TreeNode curNode=treeNode.poll();//返回第一个元素，并在队列中删除
			int curLevel=nodeLevel.poll();
			if(curNode!=null) {
				if(ans.size()<=curLevel) {
					ans.add(new ArrayList<>());
				}
				if((curLevel %2) ==0) {
					ans.get(curLevel).add(curNode.val);
				}else {
					ans.get(curLevel).add(0,curNode.val);
				}
				level=curLevel+1;
				treeNode.offer(curNode.left);
				nodeLevel.offer(level);
				treeNode.offer(curNode.right);
				nodeLevel.offer(level);
			}
		}
		return ans;
	}
	public static void main(String args[]) {
		TreeNode[] node=new TreeNode[5];
		node[0]=new TreeNode(3);
		node[1]=new TreeNode(9);
		node[2]=new TreeNode(20);
		node[3]=new TreeNode(15);
		node[4]=new TreeNode(7);
		node[0].left=node[1];
		node[0].right=node[2];
		node[2].left=node[3];
		node[2].right=node[4];
		List<List<Integer>>ans=levelorder(node[0]);
		System.out.println(ans);
	}
}