leetcode-107-Binary Tree Level Order Traversal II

自己写的代码，只考虑到了最后一层叶子节点为NULL的情况，没有考虑到中间level会有NULL的情况

/**
 * 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<int> eachLevel;
    //int level;
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result={};
        int level;
        vector<int> each;
        nodeval(root);
        level = maxDepth(root);
        int size = eachLevel.size();
        int flag = 0;
        for(int k=0; k < level-1; k++)
            flag += pow(2, k);
        long long temp = size - flag;
        long long sum = temp;
        cout << size <<endl;
        cout << flag << endl;
        cout << level << endl;
        cout << temp << endl;
        for(int i=level;i!=0;i--){
            if(i == level){
                for(int j = 0;j<sum;j++){
                    each.push_back(eachLevel[j]);
                }
            }
            else{
                temp = pow(2, i-1);
                for(int j = 0;j<temp;j++){
                    each.push_back(eachLevel[sum+j]);
                    //cout<< eachLevel[sum+j] << endl;
                }
                sum += temp;
            }
            std::reverse(each.begin(),each.end());
            result.push_back(each);
            each = {};
        }
        return result;
    }
    
    int nodeval(TreeNode* root){
        if(root == NULL){
            return 0;
        }
        if(root->right != NULL)
            nodeval(root->right);
        if(root->left != NULL)
            nodeval(root->left);
        eachLevel.push_back(root->val);
        
        return 0;
    }
    
    int maxDepth(TreeNode* root){
        if(root == NULL)
            return 0;
        
        int dl = maxDepth(root->left);
        int dr = maxDepth(root->right);
        
        return dl > dr ? dl+1 : dr+1;
    }
};

网上找到的基于递归的代码，很厉害！！

class Solution
{
public:
    vector<vector<int> > result;

    void levelTra(TreeNode *root, int level)
    {
        if(root == NULL)
            return;
        if(level == result.size())
        {
            vector<int> v;
            result.push_back(v);
        }
        result[level].push_back(root->val);
        levelTra(root->left, level+1);
        levelTra(root->right, level+1);
    }

    vector<vector<int> > levelOrderBottom(TreeNode *root) 
    {
        levelTra(root, 0);
        return vector<vector<int> >(result.rbegin(), result.rend());
    }
};