二叉树的层次遍历（深度与广度两种解法）java

解法一：
利用广度优先，对树进行一层一层的遍历，将每一层的节点放入先放入栈中，并记录这一层的节点数，即当前栈的size.并将每一层的节点放入List中，然后再进行出栈操作，每一层有多少节点就进行多少次出栈操作。每次出栈都将其子节点房入住栈中，并将其放入该层对应的List中去，直到栈为空，完成遍历。

public List<List<Integer>> levelOrder(TreeNode root) {
 Queue<TreeNode> queue=new LinkedList<>();
        List<List<Integer>> lists=new LinkedList<>();
        if (root==null){
            return lists;
        }
        //offer 与 add ,add会在栈满的情况下报异常，而offer只会返回false
        queue.offer(root);
        while (!queue.isEmpty()){
            List<Integer> list=new LinkedList<>();
            int lenth=queue.size();
            for (int i=0;i<lenth;i++){
                TreeNode treeNode=queue.poll();
                list.add(treeNode.val);
                if (treeNode.left!=null){
                    queue.offer(treeNode.left);
                }
                if (treeNode.right!=null){
                    queue.offer(treeNode.right);
                }
            }
            lists.add(list);
        }
        return lists;
}

解法二：
利用深度优先，每一次将一个分支访问结束后，才进行另外一条支路的访问。重点在于记录每次访问的节点的层数，如果与结果result的size一样，说明进入了一个新的一层，则需要创建一个新的List存放该层节点。如果不一样，则取出result中存放该层的List，放入节点，并放回result。一直往下遍历，直到节点为空，返回result即可。

public List<List<Integer>> levelOrder(TreeNode root) {

     List<List<Integer>> lists=new LinkedList<>();
     int level=0;
     return dfs(root,lists,level);

    }
    public List<List<Integer>> dfs (TreeNode root,List<List<Integer>> result, int level){
        if (root==null){
            return result;
        }
        List<Integer> list =null;
        if (result.size()==level){
            list=new LinkedList<>();
            list.add(root.val);
            result.add(list);
        }else {
            list=result.get(level);
            list.add(root.val);
            result.set(level,list);//存进去了后还是要放回去的
        }
        dfs(root.left,result,level+1);
        dfs(root.right,result,level+1);
        return result;
    }