Leetcode 103 ，Binary Tree Zigzag Level Order Traversal（二叉树Z形分层遍历）

一，问题描述1，

1，给定一棵二叉树，从上到下，进行Z字行分层遍历的，即：本层的话从左打到右，那么下层就是从右到左，最后输出结果。

2，例如：

3，解题思路：
这题和第102题解法类似，对102题的方法进行改造，使用两个Deque来实现，第一个Deque()实现本层的遍历，第二个Deque()实现下层节点的输入。

二，AC了的程序（采用Java程序）

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

public class Test2 {

    List<List<Integer>> list=new ArrayList<List<Integer>>();  //leetcode 103
    public List<List<Integer>> zigzagLevelOrder(TreeNode root)
    {
         if(root==null)
         {
             return list;
         }

        //LinkedList<TreeNode> queue=new LinkedList<TreeNode>();  //定义LinkedList类型

        //queue.offer(root);  // 首先把根节点入队列

        boolean temp1=false;  //temp1=false表示从左到右遍历，temp2=true表示从右到左遍历
        Deque<TreeNode> queue=new LinkedList<TreeNode>();//Deque是双向队列，双向队列是指该队列两端的元素既能够入队，也能出队
        Deque<TreeNode> nextqueue=new LinkedList<TreeNode>(); //记录下一层待处理结点

        queue.add(root); //首先先把二叉树的根进入双端队列
        List<Integer> templist=new LinkedList<Integer>();  //templist为临时的集；
        while(!queue.isEmpty())  //该双端队列不为空的
        {

            TreeNode node=queue.removeLast();//删除
            templist.add(node.val);  //把节点值加入到临时集

            if(temp1==false)  //如果当前是从左到右遍历的，那么下一层要从左到右添加节点
            {
                if(node.left!=null)
                {
                    nextqueue.addLast(node.left);
                }
                if(node.right!=null)
                {
                    nextqueue.addLast(node.right);
                }
            }
            else //当前是从右到左遍历的,那么下层就要从右到左添加节点的。
            {
                if(node.right!=null)
                {
                    nextqueue.addLast(node.right);
                }
                if(node.left!=null)
                {
                    nextqueue.addLast(node.left);
                }

            }

            if(queue.isEmpty())  //如果当前这层已经变为空了
            {
                Deque<TreeNode> temp=nextqueue; //就把下一层节点复制给当前节点，下一层的Deque边为空的
                nextqueue=queue; //下一层deque变为空的。
                queue=temp;

                temp1=(temp1==false)?true:false;

                list.add(templist);
                templist=new LinkedList<Integer>();


            }


        }

        return list;

    }


    public static void main(String []args)
    {
        Test2 test=new Test2();

        TreeNode root=new TreeNode(3);
        TreeNode p2=new TreeNode(9);
        TreeNode p3=new TreeNode(20);
        TreeNode p4=new TreeNode(15);
        TreeNode p5=new TreeNode(7);
        TreeNode p6=new TreeNode(4);
        TreeNode p7=new TreeNode(5);

        root.left=p2;
        root.right=p3;
        p3.left=p4;
        p3.right=p5;
        p5.left=p6;
        p5.right=p7;


         /*
        TreeNode root=new TreeNode(1);
        TreeNode p2=new TreeNode(2);
        TreeNode p3=new TreeNode(3);
        TreeNode p4=new TreeNode(4);
        TreeNode p5=new TreeNode(5);

        root.left=p2;
        root.right=p3;
        p2.left=p4;
        p3.right=p5;
        */

        List<List<Integer>> list=test.zigzagLevelOrder(root);
        Iterator<List<Integer>> it1=list.iterator();
        while(it1.hasNext())
        {
            List<Integer> list2=it1.next();
            Iterator<Integer> it2=list2.iterator();
            while(it2.hasNext())
            {
                int data=it2.next();
                System.out.print(data+" ");
            }
            System.out.println();
        }

    }
}

运行结果：