Binary Tree Level Order Traversal I & II-优快云博客

本文链接：https://blog.youkuaiyun.com/wenshente/article/details/24420753

本文详细介绍了二叉树层次遍历的两种实现方式：使用额外空间的迭代方法和不使用额外空间的递归方法。通过对比分析，帮助读者理解不同方法的优劣和适用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

(1) Binary Tree Level Order Traversal

iteratively(with extra space)

class Solution {
public:
    vector<vector<int> > levelOrder(TreeNode *root) {
        
        vector<vector<int>> ret;
        
        queue<TreeNode*> que,que1;
        
        if(!root)
            return ret;
        
        que.push(root);
        
        while(!que.empty())
        {
            vector<int> tmp;
            
            while(!que.empty())
            {
                tmp.push_back(que.front()->val);
                que1.push(que.front());
                que.pop();
            }
            
            while(!que1.empty())
            {
                if(que1.front()->left)
                    que.push(que1.front()->left);
                if(que1.front()->right)
                    que.push(que1.front()->right);
                que1.pop();
            }
            
            ret.push_back(tmp);
        }
        
        return ret;
    }
};

recursively(with no extra space)

class Solution {
private:
    void solve(int dep,TreeNode *root,vector<vector<int>> &ret){
        if(!root)
            return;
        if(ret.size()>dep)
            ret[dep].push_back(root->val);
        else
            {
                vector<int> tmp;
                tmp.push_back(root->val);
                ret.push_back(tmp);
            }
        
        solve(dep+1,root->left,ret);
        solve(dep+1,root->right,ret);
    }

public:
    vector<vector<int> > levelOrder(TreeNode *root) {
        
        vector<vector<int> > ret;
        
        solve(0,root,ret);
        
        return ret;
    }
};

(2) Binary Tree Level Order Traversal II

多加一句reverse函数即可

class Solution {
private:
    void solve(int dep,TreeNode *root,vector<vector<int>> &ret){
        if(!root)
            return;
        if(ret.size()>dep)
            ret[dep].push_back(root->val);
        else
            {
                vector<int> tmp;
                tmp.push_back(root->val);
                ret.push_back(tmp);
            }
        
        solve(dep+1,root->left,ret);
        solve(dep+1,root->right,ret);
    }
    
public:
    vector<vector<int> > levelOrderBottom(TreeNode *root) {
        vector<vector<int> > ret;
        
        solve(0,root,ret);
        
        reverse(ret.begin(),ret.end());
        
        return ret;
    }
};