二叉树系列---层次遍历二叉树

层次遍历

借助队列

public void layerTranverse(Node root){
        if(root==null){
            return;
        }

        Queue<Node> queue=new LinkedList<Node>();
        queue.add(root);
        while(!queue.isEmpty()){
            Node node=queue.remove();
            System.out.print(node.value+" ");

            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }
        }
    }

进阶1

从最后一层开始，进行层次遍历：
Given a binary tree, return the bottom-up level order traversal of its nodes’ values.
* (ie, from left to right, level by level from leaf to root).
For example:
Given binary tree{3,9,20,#,#,15,7},

return its bottom-up level order traversal as:
[
[15,7]
[9,20],
[3],
]

实现：每一层最后加入一个null元素，对于每一层，每遍历一个元素，加入到list中，当遍历到null时，将该list加入到结果集res中，然后情况list，等待加入下一层元素；

public ArrayList<ArrayList<Integer>> levelOrderBottom(TreeNode root) {
        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
        if(root==null){
            return res;
        }

        ArrayList<Integer> list=new ArrayList<Integer>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.offer(root);
        queue.offer(null);
        while(!queue.isEmpty()){
            TreeNode node=queue.poll();
            list.add(node.val);
            if(node.left!=null){
                queue.offer(node.left);
            }
            if(node.right!=null){
                queue.offer(node.right);
            }
            if(queue.peek()==null){
                queue.poll();
                if(!queue.isEmpty())
                   queue.offer(null);

                //
                res.add(0, new ArrayList<Integer>(list));
                list.clear();
            }
        }
        return res;
    }

进阶2

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).
比如

结果：
[
[3]
[20,9]
[15,7]
]

实现：奇数层从左到右；偶数层从右到左；
对于每一层，用level记录层数，每一层用list记录，向list中添加元素时，先判断是奇数层还是偶数层，每层遍历完后，将list加入到res中；

public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root){
        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
        if(root==null){
            return res;
        }
        ArrayList<Integer> list=new ArrayList<Integer>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.offer(root);
        int i=1;
        while(!queue.isEmpty()){
            TreeNode curNode=queue.poll();//每层的第一个元素
            list.add(curNode.val);

            int size=queue.size();

            if(curNode.left!=null)
                queue.offer(curNode.left);
            if(curNode.right!=null)
                queue.offer(curNode.right);

            while(size>0){
                TreeNode node=queue.poll();
                if(i%2==0){
                    list.add(0,node.val);
                }else{
                    list.add(node.val);
                }
                if(node.left!=null)
                    queue.offer(node.left);
                if(node.right!=null)
                    queue.offer(node.right);                
                size--;
            }

            //一层遍历完成
            i++;
            res.add(new ArrayList<Integer>(list));
            list.clear();
        }
        return res;
    }