LeetCode--Binary Tree Level Order Traversal

Problem:

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.

Analysis:

题意:

给定一个二叉树，返回其节点的值的水平方向的遍历。（即，从左至右，一层一层的）。

分析：用BFS和DFS均可以。但是这个题明显是针对每一层进行判断和操作，所以用BFS比较好，效率较高。

Anwser1：

BFS：一个队列

用队列将每一层的节点记录，然后轮询队列中节点，进行打印及将下一层加入队列。

public class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new LinkedList<List<Integer>>();
if(root==null) return result;
Queue<TreeNode> nodes = new LinkedList<TreeNode>();
nodes.add(root);
//isEmpty(),size()是collection接口的函数，Queue、List、Set等接口是collection的子接口
while(!nodes.isEmpty()){
LinkedList<Integer> innerList = new LinkedList<Integer>();
//这一步非常有必要，开始我只是在for循环中用i<nodes.size，没有这一步，导致错误，因为for循环中增加了nodes所以size会变
int size = nodes.size();
for(int i=0;i<size;i++){
TreeNode current = nodes.poll();
innerList.add(current.val);
if(current.left!=null) nodes.add(current.left);
if(current.right!=null) nodes.add(current.right);
}
result.add(innerList);
}
return result;
}
}

Anwser2：

BFS：利用两个队列，

public class Solution {
/**
* @param root: The root of binary tree.
* @return: Level order a list of lists of integer
*/
public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
if (root == null) {
return result;
}

ArrayList<TreeNode> Q1 = new ArrayList<TreeNode>();
ArrayList<TreeNode> Q2 = new ArrayList<TreeNode>();

Q1.add(root);
while (Q1.size() != 0) {
ArrayList<Integer> level = new ArrayList<Integer>();
Q2.clear();
for (int i = 0; i < Q1.size(); i++) {
TreeNode node = Q1.get(i);
level.add(node.val);
if (node.left != null) {
Q2.add(node.left);
}
if (node.right != null) {
Q2.add(node.right);
}
}

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

// add to result
result.add(level);
}

return result;
}
}

Anwser3：

BFS：队列加虚拟节点

public class Solution {
/**
* @param root: The root of binary tree.
* @return: Level order a list of lists of integer
*/
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); // dummy node

ArrayList<Integer> level = new ArrayList<Integer>();
while (!Q.isEmpty()) {
TreeNode node = Q.poll();
if (node == null) {
if (level.size() == 0) {
break;
}
result.add(level);
level = new ArrayList<Integer>();
Q.offer(null); // add a new dummy node
continue;
}

level.add(node.val);
if (node.left != null) {
Q.offer(node.left);
}
if (node.right != null) {
Q.offer(node.right);
}
}

return result;
}
}

Anwser4：

DFS：没有队列

每次从root开始向下查询，当查到指定的最底层，符合条件则进行相应的操作，否则返回。

public class Solution {
public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
if (root == null)   return results;
int maxLevel = 0;
while (true) {
ArrayList<Integer> level = new ArrayList<Integer>();
dfs(root, level, 0, maxLevel);
if (level.size() == 0) {
break;
}
results.add(level);
maxLevel++;
}
return results;
}
private void dfs(TreeNode root,
ArrayList<Integer> level,
int curtLevel,
int maxLevel) {
if (root == null || curtLevel > maxLevel)  return;
if (curtLevel == maxLevel) {
level.add(root.val);
return;
}
dfs(root.left, level, curtLevel + 1, maxLevel);
dfs(root.right, level, curtLevel + 1, maxLevel);
}
}

//- - - - - - - - - – - - - - - - - - – - - - - — - - - - - - - - – - - - - - - - - – - - - - - - - - – - - - - - - - - - //

加一些BFS的例子及步骤总结







//- - - - - - - - - – - - - - - - - - – - - – - - - - - - - - – - - - - – - - - - - – - - - - - - - - – - - - - - - - - - //

加一些DFS的例子及步骤总结