LeetCode 102. Binary Tree Level Order Traversal（二叉树的层次遍历，C++，Python）

Binary Tree Level Order Traversal
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]
]

思路：层次遍历二叉树可以使用队列辅助实现。为什么使用队列呢？因为我们需要按二叉树的每一层，一层一层的遍历二叉树的节点，当我们正在遍历第i层的节点时，第i层的节点有其左右孩子（如果有的话），我们需要保存第i层所有节点的子节点，以便下一次遍历第i+1层的节点，因为遍历一层只需要从左往右遍历即可，所以使用队列即可。

在遍历第i层的时候，假设第i层有size个元素在队列中，每次访问队首元素，并将队首元素出队，同时将队首元素的子节点加入队列中，如此重复size次即访问完了第i层节点，同时所有第i+1层的元素存储在队列中。如此反复，直到访问完所有二叉树的节点。

说的可能有些抽象，结合下面的代码和注释就很好理解了。

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) {
        
        queue<TreeNode *> Q;
        if(root == NULL)
            return ans;
        Q.push(root);//以下三行将根节点加入
        vector<int> t;
        t.push_back(root->val);
        int size = Q.size();//size是当前访问这一层的数量
        while(!Q.empty()){
            vector<int> t;
            while(size--){//访问size次队列，size是当前一层节点的数量
                TreeNode* tNode = Q.front();
                t.push_back(tNode->val);//将这个节点的值记录到结果中
                if(tNode->left)//将其左孩子入队，作为下一次访问
                    Q.push(tNode->left);
                if(tNode->right)//将根节点的右孩子入队，作为下一次访问
                    Q.push(tNode->right);
                Q.pop();//访问过的元素出队
            }//访问完size个元素，也就是一层的元素
            ans.push_back(t);//将这一层的元素加入到要返回的变量ans中
            size = Q.size();//重新计算下一层需要访问节点元素的个数
        }
        return ans;
    }
    
    vector<vector<int>> ans;
};

结果

python
额，感觉就是把C++代码翻译了一遍，有点无聊。。。

# 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]]
        """
        
        queue = []
        ans = []
        if root == None:
            return ans
        queue.append(root)
        size = len(queue)
        while len(queue):
            t = []
            while size:
                size -= 1
                root = queue[0]#访问队首元素并且出队
                t.append(root.val)
                queue.pop(0)

                if root.left:
                    queue.append(root.left)
                if root.right:
                    queue.append(root.right)
                
                
            size = len(queue)
            ans.append(t)
        
        return ans      

结果