leetcode------Binary Tree Level Order Traversal

标题：	Binary Tree Level Order Traversal
通过率：	29.9%
难度：	简单

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree {3,9,20,#,#,15,7},

    3
   / \
  9  20
    /  \
   15   7

 

return its level order traversal as:[

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

做了这道题感觉二叉树的知识还是很弱的，这个点确实要加强，整体思路就是分层遍历，利用一个队列进行处理，但是到底再哪一层这个问题需要处理。
　　刚开始我想到了。满二叉树每层都是固定的，那么我往队列里面放元素时每层我都放满，即，再第二层时应该往队列里面放两个节点，但是会出现左右一个是空，那么如果是空我就放一个为-1的节点，这些就把满二叉树放满了。在读取的时候用math.pow（2，num）每层读取这么多，如果读到不是-1的节点就向list中存值，这么做程序是没有问题的但是出现了超时的问题，也就是说，深度越深我要读的东西越多，增加了运行时间，然后我就想每一层数量是变动的，那么我用一个计数器来计算下下一层中我往队列中放了几个节点，那么在读取的时候我就读取几个节点就行了。等于说广度遍历一遍数组就完成了。时间复杂度就是一个O（n），这个算法应该是时间复杂度最低的算法，然后我实验后发现确实是一个时间复杂度最低的做法。
　　在网上查资料时我查到了以下几种做法：（时间复杂度都没有我想的这个高）
1、用两个队列处理，放下一层元素时把下一层元素放在另外一个队列中，例如，我在读取q1时，我把下层要遍历的元素放在q2中，下一次读取q2往q1中放元素，交替执行两层循环，增加了额外空间。
2、先算出树的深度，然后利用深度一层一层去读，这个时间复杂度是O（n^2）


下面先贴出我超时的一个算法（构造满二叉树）：

　

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result=new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue=new LinkedList<TreeNode>();
        int num=0,i=1;
        TreeNode tree=null;
        if(root==null) return result;
        queue.addLast(root);
        while(!queue.isEmpty()){
            List<Integer> tmp=new ArrayList<Integer>();
            for(i=1;i<=Math.pow(2, num);i++){
                if(!queue.isEmpty()){
                    tree=queue.removeFirst();
                    if(tree.val!=-1)
                        tmp.add(tree.val);
                    if(tree.left!=null)
                        queue.addLast(tree.left);
                    if(tree.left==null)
                    {
                        TreeNode treer=new TreeNode(-1);
                        queue.addLast(treer);
                    }
                    if(tree.right!=null)
                        queue.addLast(tree.right);
                    if(tree.right==null)
                    {   
                        TreeNode treer=new TreeNode(-1);
                        queue.addLast(treer);
                    }
                }
                else break;
            }
            result.add(tmp);
        }
        return result;
    }
}

然后我进行改进只算我放了几个进去的代码：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result=new ArrayList<List<Integer>>();
        LinkedList<TreeNode> queue=new LinkedList<TreeNode>();
        int count=1,level=0;
        if(root==null) return result;
        queue.addLast(root);
        while(!queue.isEmpty()){
            level=0;
            List<Integer> tmp=new ArrayList<Integer>();
            for(int i=0;i<count;i++){
                TreeNode tree=queue.removeFirst();
                tmp.add(tree.val);
                if(tree.left!=null){
                    queue.addLast(tree.left);
                    level++;
                }
                if(tree.right!=null){
                    queue.addLast(tree.right);
                    level++;
                }
            }
            result.add(tmp);
            count=level;
        }
        return result;
       
    }
}