【leetcode】【medium】102. Binary Tree Level Order Traversal

102. Binary Tree Level Order Traversal

Medium

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]
]

题目链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

 

思路

层序遍历也是树的广度优先遍历。

借助队列实现遍历。

不同层分开成列的方法：

法1）非递归，用一个变量记录队列长度，达到长度就结束一轮循环。

法2）非递归，当一层遍历结束后，放入一个空指针用来提示结束。

法3）递归，先计算出层数，根据层数创建好存储空间，每一层插入对应位置。

注意：入队前需要判空，或者出队时需要判空。

法一

/**
 * 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*> record;
        record.push(root);
        while(!record.empty()){
            int len = record.size();
            vector<int> restmp;
            for(int i=0; i<len; ++i){
                auto tmp = record.front();
                record.pop();
                restmp.push_back(tmp->val);
                if(tmp->left) record.push(tmp->left);
                if(tmp->right) record.push(tmp->right);
            }
            res.push_back(restmp);
        }
        return res;
    }
};

法二

注意：在向queue推入空指针前（用以分割层），要先判断queue里是否还有元素（判断树是否已遍历结束），否则会陷入无限循环空指针。

/**
 * 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*> record;
        record.push(root);
        record.push(NULL);
        vector<int> restmp;
        while(!record.empty()){
            auto tmp = record.front();
            record.pop();
            if(tmp){
                restmp.push_back(tmp->val);
                if(tmp->left) record.push(tmp->left);
                if(tmp->right) record.push(tmp->right);
            }else{
                res.push_back(restmp);
                restmp.clear();
                if(record.size()>0) record.push(NULL);
            }
        }
        return res;
    }
};

法三

递归的思考：保证不同层保存在不同位置；保证同一层内，左子节点比右子节点先访问。

满足以上条件就可以。

注意：这里对于最后结果的记录，使用的是传参，要使用引用，否则函数结束后不会修改记录。

/**
 * 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;
        int level = getLevel(root);
        res.resize(level);
        order(root, 0, res);
        return res;
    }
    void order(TreeNode* root, int level, vector<vector<int>> &res){
        if(root!=NULL){
            (res[level]).push_back(root->val);
            order(root->left, level+1, res);
            order(root->right, level+1, res);
        }
    }
    int getLevel(TreeNode* root){
        if(root==NULL) return 0;
        return max(getLevel(root->left), getLevel(root->right))+1;
    }
};

以下代码与上面的区别是：记录结果使用的是成员变量。

/**
 * 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 {
private:
    vector<vector<int>> res;
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(root==NULL) return res;
        int level = getLevel(root);
        res.resize(level);
        order(root, 0);
        return res;
    }
    void order(TreeNode* root, int level){
        if(root!=NULL){
            (res[level]).push_back(root->val);
            order(root->left, level+1);
            order(root->right, level+1);
        }
    }
    int getLevel(TreeNode* root){
        if(root==NULL) return 0;
        return max(getLevel(root->left), getLevel(root->right))+1;
    }
};