二叉树的层序遍历

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]
]

 

confused what"{1,#,2,3}"means? > read more on how binary tree is serialized on OJ.

OJ's Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

   1
  / \
 2   3
    /
   4
    \
     5

The above binary tree is serialized as"{1,2,3,#,#,4,#,#,5}".

 

package leetcode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class Binary_tree_level_order_traversal {
      public static void main(String[] args) {
          TreeNode t1 = new TreeNode(1);
          TreeNode t2 = new TreeNode(2);
          t1.left = t2;
          System.out.println(levelOrder(t1));
        
    }
      
      public static ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
          Queue<TreeNode> p = new LinkedList<>();         //建立两个队列,这样来区分上下两个层次,以免交叉弄错
          Queue<TreeNode> q = new LinkedList<>();
          ArrayList<Integer> al = new ArrayList<>();
          ArrayList<ArrayList<Integer>> AL = new ArrayList<>();
          if(root == null) {
              return AL;
          }else {
              p.add(root);
          }
          while(!p.isEmpty() || !q.isEmpty()) {              //依次把一个队列的元素取出来之后,如果存在左右子节点,则把左右子节点放到另一个队列之中
                                                             //然后再遍历另一个队列
              while(!p.isEmpty()) {
                  if(p.peek().left != null) {
                      q.add(p.peek().left);
                  }
                  if(p.peek().right != null) {
                      q.add(p.peek().right);
                  }
                  al.add(p.remove().val);
              }
              if(!al.isEmpty()) {
                  ArrayList<Integer> temp = new ArrayList<>(al);        //把层序遍历结果拷贝出来,然后放到AL中
                  AL.add(temp);
                  al.clear();
              }
              
              while(!q.isEmpty()) {
                  if(q.peek().left != null) {
                      p.add(q.peek().left);
                  }
                  if(q.peek().right != null) {
                      p.add(q.peek().right);
                  }
                  al.add(q.remove().val);
              }
              if(!al.isEmpty()) {
                  ArrayList<Integer> temp1 = new ArrayList<>(al);
                  AL.add(temp1);
                  al.clear();
              }
          }
        return AL;
          
      }
}
//以下是牛客网的最优解法,其是通过队列的规模来保证两个层次之间互相不干扰
/*public class Solution {
    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if(root == null)
            return res;
         
        queue.offer(root);
         
        while(queue.size() > 0){
            ArrayList<Integer> list = new ArrayList<Integer>();
            int size = queue.size();       //是在遍历新添加之前求size,然后再循环中size不变,从而保证了是上一层次,不会夹杂新添加的的下一个层次的元素
            for(int i =0;i < size;i ++){    
                TreeNode tmp = queue.poll();
                if(tmp.left != null)
                    queue.offer(tmp.left);
                if(tmp.right != null)
                    queue.offer(tmp.right);
                list.add(tmp.val);
            }
            res.add(list);
        }
        return res;
    }
}*/