leetcode 102. 二叉树的层次遍历 Binary Tree Level Order Traversal（使用c++/java/python）【使用并总结队列】

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

https://leetcode.com/problems/binary-tree-level-order-traversal/

使用队列保存待处理的结点；使用双层vector/list保存每层的结点值。

初始状态将根节点入队，然后每次初始化一个单层vector/list保存本层结点值。

本层结点个数就是当前队列中的元素个数，因为当第n层处理完时，第n层结点的左右孩子都已入队，队中元素即是n+1层的有效结点数。

对于每一层，先将队首出队，再将其左右孩子中非空的结点入队，队首的值进入本层的vector/list

执行用时： c++ 16ms； java 1ms； python 52ms

队列常用操作：

c++

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root==NULL) return res;
        
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
        {
            vector<int> lev;
            int levnum = que.size();
            for(int i=0;i<levnum;i++)
            {
                TreeNode* head = que.front();
                que.pop();
                if(head->left) que.push(head->left);
                if(head->right) que.push(head->right);
                lev.push_back(head->val);
            }
            res.push_back(lev);
        }
        return res;
    }
};

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 LinkedList<List<Integer>>();
        if(root==null) return res;
        
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(root);
        while(!que.isEmpty())
        {
            List<Integer> lev = new LinkedList<Integer>();
            int levnum = que.size();
            for(int i=0;i<levnum;i++)
            {
                TreeNode head = que.poll();
                if(head.left!=null) que.offer(head.left);
                if(head.right!=null) que.offer(head.right);
                lev.add(head.val);
            }
            res.add(lev);
        }
        return res;
    }
}

python

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

class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []  #嵌套列表，保存最终结果
        if root is None:
            return res
        
        from collections import deque
        que = deque([root])  #队列，保存待处理的结点
        while len(que)!=0:
            lev = []  #列表，保存该层的结点的值
            thislevel = len(que)  #该层结点个数
            while thislevel!=0:
                head = que.popleft()  #弹出队首结点
                #队首结点的左右孩子入队
                if head.left is not None:
                    que.append(head.left)
                if head.right is not None:
                    que.append(head.right)
                lev.append(head.val)  #队首结点的值压入本层
                thislevel-=1
            res.append(lev)
        return res