26.二叉树的层序遍历（妙）+二叉树的锯齿形层序遍历（ArrayList和LinkedList）

ArrayList和LinkedList的区别

二叉树的层序遍历

解题思路：完全利用了图的广度优先遍历，即利用队列先进先出的特点，但这里二叉树的层序遍历，麻烦的是需要区分每层的节点到底是哪几个（为了同层节点的值加入一个list中）。保证每次迭代后，队列中只剩下----下一次要遍历的那一层节点的数据。每层在队列中的节点，它们出队的时候，同时将自己的左右子节点入队，为下一层遍历服务。

class Solution {

     //为了区分每层的节点：确保每次迭代结束后，一个队列中只有本层的节点,
     //这样方便遍历本层的节点，来进一步遍历完下一层的节点
   
    public List<List<Integer>> levelOrder(TreeNode root) {

         List<List<Integer>> container=new ArrayList<List<Integer>>();
         LinkedList<TreeNode> queue=new LinkedList<>();

         if(root==null){
             return container;
         }
         //初始化队列
         queue.offer(root);

         while(!queue.isEmpty()){

             List<Integer> list=new ArrayList<>();
             int currentLevelNum=queue.size();//本层节点数

       //将本层队列中的节点按照从左往右一一出队，出队的时候同时将自己的左右子节点入队，为下一层遍历服务
       //区分层的原因是，为了分割出一层的列表值
             for(int i=0;i<currentLevelNum;i++){
                 TreeNode temp=queue.poll();
                 list.add(temp.val);

                 //按照从左往右的顺序
                 if(temp.left!=null){
                     queue.offer(temp.left);
                 }
                 if(temp.right!=null){
                     queue.offer(temp.right);
                 }
             }


          container.add(list);

         }
         return container;

    }

}

相较于原来只是加入大容器的顺序相反

container.add(0,list);//每次将列表的值添加在列表的头部

二叉树的锯齿形层序遍历

Queue(先进先出)

Deque

官方解答(整体思想同层序遍历，只是每层的队列顺序不同)

//节点队列的入队列的方式和层序遍历完全一样
//进入数值队列的方式需要按flag来决定从队首还是队尾进入
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {

        //注意创建的是“队列列表”
        List<List<Integer>> ans = new LinkedList<List<Integer>>();
        if (root == null) {
            return ans;
        }

       //节点队列（用于帮助每次更新一个列表--每次队列都只存放一层的节点--）
        Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
        nodeQueue.offer(root);
        boolean isOrderLeft = true;

        while (!nodeQueue.isEmpty()) {

            //用于生成一组数值的列表（确定每层的节点个数==数值列表的个数）
            Deque<Integer> levelList = new LinkedList<Integer>();
            int size = nodeQueue.size();

            for (int i = 0; i < size; ++i) {

                //约定：每次从节点队列的末尾出来（先进先出--第一个进去的叫做头--先出头元素）
                TreeNode curNode = nodeQueue.poll();

                //同一层中的节点的值--按照队列的逆序还是正序--进入数值队列
                if (isOrderLeft) {
                    levelList.offerLast(curNode.val);//从数值队列末尾加元素
                } else {
                    levelList.offerFirst(curNode.val);//从数值队列头加元素
                }


                //从节点队列的末尾加入--本层节点的左右节点（和层序遍历从左往右--看队列）
                if (curNode.left != null) {
                    nodeQueue.offer(curNode.left);
                }
                if (curNode.right != null) {
                    nodeQueue.offer(curNode.right);
                }
            }

            ans.add(new LinkedList<Integer>(levelList));
            isOrderLeft = !isOrderLeft;//每次翻转标记

        }

        return ans;
    }
}