LeetCode 102. 二叉树的层次遍历

这是一道非常经典的二叉树层次遍历的问题，就是将二叉树逐层输出，首先来看一下题目：

看到题目中的层次遍历，我们首先想到的就是广度优先搜索算法BFS，我们来看看如何实现广度优先算法，首先我们将二叉树放入队列中，然后遍历队列，每次将节点的左右孩子放入队列的尾部，并将当层的节点输出，这样就可以实现广度优先遍历，代码如下所示。
python：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        result = []
        queue = collections.deque()
        queue.append(root)
        
        # visited = set(root)
        
        while queue:
            level_size = len(queue)
            current_level = []
            
            for i in range(level_size):
                node = queue.popleft()
                current_level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(current_level)
        return result

java：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null)   return res;
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        
        while (!queue.isEmpty()){
            int levelSize = queue.size();
            List<Integer> currentLevel = new ArrayList<>();
            
            for(int i = 0; i < levelSize; i++){
                TreeNode currentNode = queue.poll();
                currentLevel.add(currentNode.val);
                if (currentNode.left != null){      
                    queue.add(currentNode.left);
                }
                if (currentNode.right != null){
                    queue.add(currentNode.right);
                }
            }
            res.add(currentLevel);
        }
        return res;
    }
}

由此可见，在BFS算法中，也就是层次遍历算法中，我们是使用队列来实现广度优先搜索的，希望对大家对广度优先搜索算法的理解有所帮助，谢谢。