Leetcode102-Binary Tree Level Order Traversal（107,103，199）

题目

二叉树层次遍历

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

    3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

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

思路：主要是BFS+队列

伪代码

enqueue(Q, root)

do

     node = dequeue(Q)

     process(node) //如把内容列印

     for   each child of node

         enqueue(Q, child)

while   Q is not empty

关键在于，每次处理一层，这一层的节点会存储在队列中

队列常用的操作 offer poll peek（取队首，且不删除） - 总结java常用数据结构

当前层元素出队之前，要将元素的子节点入队

队列中一次存储的元素就是一层的节点，当队首元素出队的时候，把队首元素的孩子节点入队就可以了（前面这两句可以交换位置，也就是既可以先出队首元素，在把节点的孩子入队，也可以先入队队首元素的）

思路：

根节点入队

while(队列不空){

队列长度为当前层的节点数目

//此时队列中的元素即为一层的元素

遍历队列中元素{

遍历元素的孩子

入队

出队队首元素

}

}

queue.Enqueue(node)

图解过程（待添加）

代码：

public class Solution102 {
	
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList();
        List<List<Integer>> wrapperList = new ArrayList<>();
        
        //当root为空时，应该返回一个空的列表
        if(root == null)
        	return wrapperList;
        queue.offer(root);
        
        while(!queue.isEmpty()){
        	//当前层节点数目
        	int levelNum = queue.size();
        	List<Integer> subList = new ArrayList<>();
        	//从左到右遍历当前层，将当前层元素的子节点入队，将当前层元素出队
        	for(int i = 0;i < levelNum;i++){
        		if(queue.peek().left != null) queue.offer(queue.peek().left);
        		if(queue.peek().right != null) queue.offer(queue.peek().right);
        		subList.add(queue.poll().val);
        	}
        	
        	wrapperList.add(subList);
        }
        
        return wrapperList;
        	
        
    }

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

Leetcode107-二叉树层次遍历II

题目：

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

    3
   / \
  9  20
    /  \
   15   7

return its bottom-up level order traversal as:

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

思路：

这个题和102差不多，只不过顺序稍微有点变化，用双端队列处理就可以了。

代码：

public class Solution107 {
	
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
    	List<List<Integer>> res = new LinkedList();
    	//双端队列
    	Queue<TreeNode> queue = new LinkedList();
    	
    	if(root == null)
    		return res;
    	
    	queue.offer(root);
    	while(!queue.isEmpty()){
    		//当前层的节点数
    		int levelNum = queue.size();
    		List<Integer> subList = new LinkedList();
    		//遍历当前层
    		for(int i = 0 ;i < levelNum;i++){
    			if(queue.peek().left != null) queue.offer(queue.peek().left);
    			if(queue.peek().right != null) queue.offer(queue.peek().right);
    			subList.add(queue.poll().val);
    		}
    		((LinkedList) res).push(subList);
    	}
    	return res;
    }
    
}

LeetCode103 之字形遍历二叉树

题目：

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

    3
   / \
  9  20
    /  \
   15   7

return its zigzag level order traversal as:

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

思路：

这个和层次遍历差不多，只不过需要一个层数计数器，在层数偶数的情况下从左到右，在奇数的情况下从右到左边

root入队

//层数计数器

int i = 0;

//遍历层

while(层/队列不空){

队列长度是当前层的节点数目

声明一个保存当前层节点值的列表

遍历当前层中的节点{

遍历元素的孩子

入队

如果是偶数层

出队队首元素，添加到subList尾部

如果是奇数层

出队队首元素，添加到subList首部

}

层数加1，level++

}

代码

public class Solution103 {
	
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
    	List<List<Integer>> res = new LinkedList();
    	//双端队列
    	Queue<TreeNode> queue = new LinkedList();
    	
    	if(root == null)
    		return res;
    	
    	int level = 0;
    	queue.offer(root);
    	while(!queue.isEmpty()){
    		//当前层的节点数
    		int levelNum = queue.size();
    		LinkedList<Integer> subList = new LinkedList();
    		//遍历当前层
    		for(int i = 0 ;i < levelNum;i++){
    			if(queue.peek().left != null) queue.offer(queue.peek().left);
    			if(queue.peek().right != null) queue.offer(queue.peek().right);
    			if(level % 2 == 0){//层数是偶数
    				subList.add(queue.poll().val);
    			}else{//层数是奇数
    				subList.push(queue.poll().val);
    			}
    			
    		}
    		((LinkedList) res).add(subList);
    		level++;
    	}
    	return res;
    
    }

}

Leetcode199 Binary Tree Right Side View   

题目

二叉树右侧视图

For example:
Given the following binary tree,

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

You should return [1, 3, 4].

思路：

和层次遍历视图差不多，不过在往结果添加的时候，只需要添加当前层的最后一个值（队列中的最后一个元素）

代码：

public class Solution199v1 {
	
    public List<Integer> rightSideView(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList();
        List<Integer> wrapperList = new ArrayList<>();
        
        if(root == null)
        	return wrapperList;
        queue.offer(root);
        
        while(!queue.isEmpty()){
        	//当前层节点数目
        	int levelNum = queue.size();
        	List<Integer> subList = new ArrayList<>();
        	//从左到右遍历当前层，将当前层元素的子节点入队，将当前层元素出队
        	for(int i = 0;i < levelNum;i++){
        		if(queue.peek().left != null) queue.offer(queue.peek().left);
        		if(queue.peek().right != null) queue.offer(queue.peek().right);
        		subList.add(queue.poll().val);
        	}
        	
        	wrapperList.add(subList.get(subList.size()-1));
        }
        
        return wrapperList; 
    }

}