003-102-Binary Tree Level Order Traversal 层序遍历二叉树

Description

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,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
return its level order traversal as:

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

分析 使用BFS

树的层序遍历很简单，树可以看成图的退化，对树的广度优先遍历就是层序遍历，我们用一个队列就可以完成。每访问一个节点，执行队列的出队操作，同时把他的子节点插入到队列末尾，持续访问直至队列为空。当要将每一层区别开来的时候好似麻烦一点，其实也简单，我们可以从根节点开始访问，根节点作为特殊的一层，只有一个节点。每访问一层就为该层的子节点，也就是就为下一层的节点新建立一个队列。

code

尾递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> opList=new ArrayList<List<Integer>>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        if(root!=null){
            queue.offer(root);
            levelOrder(opList,queue);
        }
        return opList;    
    }
    public void levelOrder(List<List<Integer>> opList, Queue<TreeNode> queue){
        if(queue.isEmpty())return;
        else{
            List<Integer> list=new ArrayList<Integer>();//存放一层的节点的值
            Queue<TreeNode> nextLevelQueue=new LinkedList<TreeNode>();//用以存放下一层的节点
            while(!queue.isEmpty()){//访问一层的队列
                TreeNode next=queue.poll();
                list.add(next.val);
                if(next.left!=null)nextLevelQueue.offer(next.left);
                if(next.right!=null)nextLevelQueue.offer(next.right);
            }
            opList.add(list);//插入到输出
            levelOrder(opList,nextLevelQueue);//尾递归，消耗很大，转迭代
        }
    }
}

用时4毫秒，可以看到我使用的是尾递归，可以将其改为迭代方式，减少不必要的开销。可以看到，每访问一层，就创建一个节点队列以用于存放下一层的节点。

迭代

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> opList=new ArrayList<List<Integer>>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        if(root!=null){
            queue.offer(root);
            //levelOrder(opList,queue);
            while(!queue.isEmpty()){
                List<Integer> list=new ArrayList<Integer>();
                Queue<TreeNode> nextLevelQueue=new LinkedList<TreeNode>();


                while(!queue.isEmpty()){//访问一层的节点
                    TreeNode next=queue.poll();
                    list.add(next.val);
                    if(next.left!=null)nextLevelQueue.offer(next.left);
                    if(next.right!=null)nextLevelQueue.offer(next.right);
                }//while
                opList.add(list);
                queue=nextLevelQueue;//访问下一层
            }//while
        }
        return opList;    
    }

用时3毫秒。可以看到，在运行期间为每一层都创建一个新的队列。是否可以改为只使用一个队列？如果可以知道该层的节点数量k，就可以从队列中取出层的该k个节点，也可继续将下一层的节点插入该队列。可以在每层遍历前获得队列的大小，就获得了该层的节点数k。

只使用一个队列的代码

public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> opList=new ArrayList<List<Integer>>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        if(root!=null){
            queue.offer(root);
            //levelOrder(opList,queue);
            while(!queue.isEmpty()){
                List<Integer> list=new ArrayList<Integer>();
                int levelSize=queue.size();
                for(int i=0;i<levelSize;i++){
                    TreeNode next=queue.poll();
                    list.add(next.val);
                    if(next.left!=null)queue.offer(next.left);
                    if(next.right!=null)queue.offer(next.right);
                }//while
                opList.add(list);
            }//while
        }
        return opList;    
    }

}

DFS 的思路

在讨论区看到有buddy用DFS的思路，很强。ac后可以自行前往评论区看看。