LeetCode—Level Order

Qustion:

层次遍历二叉树。

Given binary tree [3,9,20,15,7null,null],

3

/ \

9 20

/ \

15 7

return its level order traversal as:

[

[3],

[9,20],

[15,7]

]

Idea:

采用队列，但是根据其返回形式，需要打印每一层，如何判断该层结束是需要考虑的。其实层次遍历实现是通过队列，首先将根入队，只要队不为空时，每次出队一个，如果出队的节点有左右子节点就入队，此时入队的左右子节点即是下一层的对象。所以可以利用一个新的队列2来存放。当队列1为空时，说明该层遍历完，则存入List中，把队列2赋值给队列1再进行循环。其实是两层循环。

因为是用java写的，java中的Queue不太会用，就自己写了队列类

public List<List<Integer>> levelOrder(TreeNode root) {
Queue  queue = new Queue(1024);
List<List<Integer>> list = new ArrayList<List<Integer>>();
if(root==null){
return list;
}

queue.push(root);
//每层节点集
List<Integer> level = new ArrayList<Integer>();
do{
Queue  queue2 = new Queue(1024);
while(!queue.isEmpty()){
//取对头节点
TreeNode head = queue.peek();
level.add(head.val);

//弹出队头
queue.pop();

if(head.left!=null){
queue2.push(head.left);
}
if(head.right!=null){
queue2.push(head.right);
}
}
list.add(level);
level = new ArrayList<Integer>();
queue = queue2;
}while(!queue.isEmpty());

return list;
}

public class Queue {
/**
* 实现队列
*/
int first,last,maxSize;
TreeNode[] queue;
public Queue(int size){
first = last = -1;
maxSize = size;
queue = new TreeNode[maxSize];
}
public boolean isEmpty(){
if(first==-1){
return true;
}else {
return false;
}
}
public boolean isFull(){
if(first==(last+1)%maxSize){
return true;
}else {
return false;
}
}
//push
public boolean push(TreeNode num){
if(this.isFull()){
System.out.println("queue is full!");
return false;
}if(this.isEmpty()){
first = last = 0;
}else{
last = (last+1)%maxSize;
}
queue[last] = num;

return true;
}

public TreeNode pop(){
TreeNode num = queue[first];
if(this.isEmpty()){
queue = new TreeNode[maxSize];
return null;
}
if(first==last){
//到达队尾，清空数组
queue = new TreeNode[maxSize];
first = last = -1;
return num;
}

first=(first+1)%maxSize;
return num;
}

public TreeNode peek(){
if(first==-1) return null;
else return queue[first];
}
}