linkList解二叉树的锯齿形层次遍历

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

您在真实的面试中是否遇到过这个题？ Yes
样例
给出一棵二叉树 {3,9,20,#,#,15,7},

3

/ \
9 20
/ \
15 7
返回其锯齿形的层次遍历为：

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

/**
 * 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;
 *     }
 * }
 */

这里用的是LinkedList的pollLast方法，当然用stack会更合适。

public class Solution {
    /**
     * @param root: A Tree
     * @return: A list of lists of integer include the zigzag level order traversal of its nodes' values.
     */
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        // write your code here

       List<List<Integer>> result = new ArrayList<List<Integer>>();
        if (root == null) {
            return result;
        }
        LinkedList<TreeNode> currDeque = new LinkedList<TreeNode>();
        LinkedList<TreeNode> nextDeque = new LinkedList<TreeNode>();
        LinkedList<TreeNode> tmp;
        TreeNode node = null;
        currDeque.offer(root);
        boolean tag = true;

        while(!currDeque.isEmpty()){
             List<Integer> temp = new ArrayList<Integer>();

            while(!currDeque.isEmpty()){

                    node = currDeque.pollLast();
                    temp.add(node.val);

                    if(tag){
                        if(node.right!=null){
                            nextDeque.offer(node.right);
                        }
                        if(node.left!=null){
                            nextDeque.offer(node.left);
                        }

                    }
                    else{
                        if(node.left!=null){
                            nextDeque.offer(node.left);
                        }
                        if(node.right!=null){
                            nextDeque.offer(node.right);
                        }
                    }
            }
            tag = !tag;
            tmp = currDeque;
            currDeque = nextDeque;
            nextDeque = tmp;
            result.add(temp);
        }

        return result;

    }
}

stack方法

1：第一二维的List集合。
2：定义当前行的Stack（采用后进先出；先进先出行不通）即currStack和下一行nextStack，还有做转接的tmpStack，每次其实就是读当前行，和存下一行，当前行读完，转读下一行的工作。
3：中间设置临时变量node(接住每一个pop出来的)，和每一行的List。
4：读完一行加一行。

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        // write your code here

       List<List<Integer>> list = new ArrayList<List<Integer>>();

       if(root == null){
           return list;
       }

       Stack<TreeNode> currStack = new Stack<TreeNode>();
       Stack<TreeNode> nextStack = new Stack<TreeNode>();
       Stack<TreeNode> tmpStack = new Stack<TreeNode>();
       TreeNode node;
       boolean flag = false;
       currStack.push(root);

       while(!currStack.isEmpty()){

           List<Integer> lt = new ArrayList<Integer>();
           while(!currStack.isEmpty()){

               node = currStack.pop();
               lt.add(node.val);
               if(flag){
                   if(node.right!=null){
                       nextStack.push(node.right);
                   }
                   if(node.left!=null){
                       nextStack.push(node.left);
                   }
               }else{
                   if(node.left!=null){
                       nextStack.push(node.left);
                   }
                   if(node.right!=null){
                       nextStack.push(node.right);
                   }
               }
           }
           tmpStack = currStack;
           currStack = nextStack;
           nextStack = tmpStack;
           flag=!flag;
           list.add(lt);
       }
       return list;
    }