Binary Tree Zigzag Level Order Traversal 二叉树ZigZag打印

Binary Tree Zigzag Level Order Traversal

  My Submissions

Question Editorial Solution

Total Accepted: 61552  Total Submissions: 213085  Difficulty: Medium

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.

 /**
	  * Definition for a binary tree node.
	  * public class TreeNode {
	  *     int val;
	  *     TreeNode left;
	  *     TreeNode right;
	  *     TreeNode(int x) { val = x; }
	  * }
	  */
	  //LeetCode, Binary Tree Zigzag Level Order Traversal

	 //广度优先遍历，用一个bool记录是从左到右还是从右到左，每一层结束就翻转一下。

	 // 迭代版，时间复杂度O(n)，空间复杂度O(n)

	  import java.util.*;
	 public class Solution {
	     public List<List<Integer>> zigzagLevelOrder(TreeNode root) {

	         List<Integer> list=new LinkedList<Integer>();
	         List<List<Integer>> levelList=new LinkedList<List<Integer>>();
	         Queue<TreeNode> que=new LinkedList<TreeNode>();
	         if(root == null)
	             return levelList;
	         que.offer(root);
	         que.offer(null);
	         boolean left_to_right = true;
	         TreeNode cur=root;
	         while(!que.isEmpty()){
	             TreeNode node = que.poll();
	             if(node!=null){
	                 list.add(node.val);
	                 if(node.left!=null)
	                     que.offer(node.left);
	                 if(node.right!=null)
	                     que.offer(node.right);
	             }else{
	                 if(left_to_right){
	                     levelList.add(new LinkedList(list));
	                 }else{
	                     Collections.reverse(list);
	                     levelList.add(new LinkedList(list));
	                 }
	                 list.clear();
	                 left_to_right=!left_to_right;
	                 if(que.size()>0) que.offer(null);
	             }
	         }
	         return levelList;
	     }
	 }

利用双端队列：

	 import java.util.*;
	 public class ZigZagPrint {
	     public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
	         List<Integer> list=new LinkedList<Integer>();
	         List<List<Integer>> levelList=new LinkedList<List<Integer>>();
	         Deque<TreeNode> que=new LinkedList<TreeNode>();
	         if(root==null)
	         return levelList;
	         TreeNode node=root;
	         que.offerFirst(root);
	         TreeNode last=root;
	         TreeNode nlast=null;
	         boolean orderFlag=true;
	         while(!que.isEmpty()){
	             if(orderFlag){
	             node = que.pollFirst();
	             list.add(node.val);
	                 if(node.left!=null)
	                     que.offerLast(node.left);
	                     nlast=nlast==null?node.left:nlast;
	                     //list.add(node.)
	                 if(node.right!=null){
	                     que.offerLast(node.right);
	                      nlast=nlast==null?node.right:nlast;
	                     //nlast=node.right;
	                 }
	             } else
	                 {
	                  node = que.pollLast();
	                 list.add(node.val);
	                 if(node.right!=null)
	                     que.offerFirst(node.right);
	                     nlast=nlast==null?node.right:nlast;
	                     //list.add(node.)
	                 if(node.left!=null){
	                     que.offerFirst(node.left);
	                     nlast=nlast==null?node.left:nlast;
	                     //nlast=node.left;
	                 }                    
	                 }
	                 if(node==last)
	                     {
	                         List<Integer> listCopy=new LinkedList<Integer>(list);
	                        levelList.add((LinkedList<Integer>)listCopy);
	                         list.clear();
	                         last=nlast;
	                         nlast=null;
	                         orderFlag=!orderFlag;
	                     }
	         }
	         return levelList;
	     }
	 }