二叉树层次遍历

http://www.lintcode.com/zh-cn/problem/binary-tree-level-order-traversal/#

注意点：1.分割层的三种方式： 1.提前记录好每层的结点数目，poll时poll指定数目的结点；

　　　　　　　　　　　　　 2.用两个Queue，每个queue中只放一层的结点

　　　　　　　　　　　　　 3.引入哨兵结点作为标记，遇到哨兵结点说明层结束了（相当于层结束符）

　　　　2.因为result里存的是level的内存地址，而并不是层序遍历的值，所以对每一层都必须new一个level，而不能clear后重复使用。

　　　　3.看解4代码，区分什么是DFS，BFS

错误点：queue是抽象的，实例化时，实例成LinkedList

　　　　q.isEmpyt()  不是q.empty()

　　　　入队 q.offer(E)    出队  q.poll()

解1：一个queue

public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(root == null) return result;
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(root);
        ArrayList<Integer> arr = null;
        while(!q.isEmpty()){
            arr = new ArrayList<Integer>();
            int num = q.size();
            for(int i = 0; i <num; i++) {
                TreeNode temp = q.poll();
                arr.add(temp.val);
                if(temp.left != null) q.offer(temp.left);
                if(temp.right != null) q.offer(temp.right);
            }
            result.add(arr);
        }
        return result;
    }

解3：引入哨兵结点dummy = null，将每一层分割：  A

　　　　　　　　　　　　　　　　　　　　　　    B    C        Queue： A#BC#  

　　　　　　　　　　　　　　　　　　队列中依次poll时， 遇到null，说明这一层结束了。

 public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if (root == null) return result;        
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(root);
        q.offer(null);
        ArrayList<Integer> level = new ArrayList<Integer>();
        while(!q.isEmpty()) {
            TreeNode temp = q.poll();
            if(temp != null) {
                level.add(temp.val);
                if(temp.left != null) q.offer(temp.left);
                if(temp.right != null) q.offer(temp.right);
            //    continue;      这里可以写成continue，也可以用else，两种方法都行。
            } else {
                q.offer(null);
                if(level.size() == 0) break;
                result.add(level);
                level = new ArrayList<Integer>();  //这里不能level.clear();因为result里存的是level的内存地址，而并不是层序遍历的值，clear后，result里存的都是
                                                   //空List，所以必须是新建一个List引用，而用原来的lIst是不行的。
            }
        }
        return result;
  }

解4： 限定深度的DFS

 public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();    
        if (root == null) return result;      
        int targetDep = 1, currDep = 1;
        ArrayList<Integer> level = new ArrayList<Integer>();
        while(true) {
            dfs(root,currDep,targetDep,level);
            if(level.size() == 0) break;
            result.add(level);
            level = new ArrayList<Integer>();
            targetDep++;
            currDep = 1;  //  写不写都行，说明dfs在传currDep时是值传递，在调用过程中，值并不会发生变化。
        }
        return result;
        
}
// 函数在调用过程中调用了自己本身，迭代调用，说明是深度优先；BFS是不会有递归的调用的。
private void dfs(TreeNode root, int currDep, int targetDep, ArrayList<Integer> level) {
    if(root == null || currDep > targetDep) return;
    if(currDep == targetDep) level.add(root.val);
    dfs(root.left, currDep + 1, targetDep, level);
    dfs(root.right, currDep + 1, targetDep, level);
}

 解2：用两个queue：

// swap q1 and q2
            ArrayList<TreeNode> temp = Q1;
            Q1 = Q2;
            Q2 = temp;

 这样在while循环判断时，只需要判断q1非空即可，循环内部，q2始终放q1结点的子结点，简化代码。

  public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(root == null) return result;
        Queue<TreeNode> q1 = new LinkedList<TreeNode>();
        Queue<TreeNode> q2 = new LinkedList<TreeNode>();
        q1.offer(root);
        while(!q1.isEmpyt() || !q2.isEmpyt()) {
            if(!q1.isEmpyt()) {
                ArrayList<Integer> level = new ArrayList<Integer>();
                TreeNode temp = null;
                while((temp = q1.poll()) != null) {
                    if(temp.left != null) q2.offer(temp.left);
                    if(temp.right != null) q2.offer(temp.right);
                    level.add(temp.val);    
                }    
            }
            if(!q2.isEmpyt()) {
                ArrayList<Integer> level = new ArrayList<Integer>();
                TreeNode temp = null;
                while((temp = q2.poll()) != null) {
                    if(temp.left != null) q1.offer(temp.left);
                    if(temp.right != null) q1.offer(temp.right);
                    level.add(temp.val);    
                }    
            }
        }
        return result;
  }