Binary Tree Level Order Traversal I & II

最新推荐文章于 2019-01-18 03:41:03 发布

i_dont_give_a_fxxk

最新推荐文章于 2019-01-18 03:41:03 发布

阅读量307

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/wenshente/article/details/24420753

版权

leetcode 专栏收录该内容

60 篇文章 0 订阅

订阅专栏

(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;
    }
};