Binary Tree Level Order Traversal II

Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its bottom-up level order traversal as:

[
  [15,7],
  [9,20],
  [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:
    void level_travel_tree(int level, TreeNode* root, vector<vector<int>>& TreeNodeList)
    {
        if (root)
        {
            if (TreeNodeList.size() == level)
				TreeNodeList.resize(level + 1);
            TreeNodeList[level].push_back(root->val);
            level_travel_tree(level + 1, root->left, TreeNodeList);
            level_travel_tree(level + 1, root->right, TreeNodeList);
        }
    }
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> answer;
        level_travel_tree(0, root, answer);
        reverse(answer.begin(), answer.end());
        return answer;
    }
};

# 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):

# dfs recursively
def levelOrderBottom1(self, root):
    res = []
    self.dfs(root, 0, res)
    return res

def dfs(self, root, level, res):
    if root:
        if len(res) < level + 1:
            res.insert(0, [])
        res[-(level+1)].append(root.val)
        self.dfs(root.left, level+1, res)
        self.dfs(root.right, level+1, res)
        
# dfs + stack
def levelOrderBottom2(self, root):
    stack = [(root, 0)]
    res = []
    while stack:
        node, level = stack.pop()
        if node:
            if len(res) < level+1:
                res.insert(0, [])
            res[-(level+1)].append(node.val)
            stack.append((node.right, level+1))
            stack.append((node.left, level+1))
    return res
 
# bfs + queue   
def levelOrderBottom(self, root):
    queue, res = collections.deque([(root, 0)]), []
    while queue:
        node, level = queue.popleft()
        if node:
            if len(res) < level+1:
                res.insert(0, [])
            res[-(level+1)].append(node.val)
            queue.append((node.left, level+1))
            queue.append((node.right, level+1))
    return res

# 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 levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        ans = []
        def Level_travel_tree(level, root, ans):
            if root:
                if level == len(ans):
                    ans.append([])
                ans[level].append(root.val)
                Level_travel_tree(level + 1, root.left, ans)
                Level_travel_tree(level + 1, root.right, ans)
            
        Level_travel_tree(0, root, ans)
        
        return ans[::-1]

vector<vector<int> > res;

void DFS(TreeNode* root, int level)
{
    if (root == NULL) return;
    if (level == res.size()) // The level does not exist in output
    {
        res.push_back(vector<int>()); // Create a new level
    }
    
    res[level].push_back(root->val); // Add the current value to its level
    DFS(root->left, level+1); // Go to the next level
    DFS(root->right,level+1);
}

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

vector<vector<int>> levelOrderBottom(TreeNode* root) {
        typedef pair<TreeNode*, int> snodeT;
        typedef vector<vector<int>> VEC;
        
        VEC res;
        stack<snodeT> snode;
        
        snode.push(make_pair(root, 0));
        
        while(!snode.empty())
        {
            snodeT n = snode.top();
            snode.pop();
            TreeNode* p = n.first;
            int level = n.second;
            
            if (p)
            {
                if (res.size() < level + 1)
                    res.push_back(vector<int>());
                res[level].push_back(p->val);
                snode.push(make_pair(p->right, level + 1));
                snode.push(make_pair(p->left,  level + 1));
            }
        }
        return VEC(res.rbegin(), res.rend());
    }

    vector<vector<int>> levelOrderBottom(TreeNode* root)
    {
        typedef pair<TreeNode*, int> pairT;
        typedef vector<vector<int>>  vec_vec_int;
        list<pairT> nodelist;
        nodelist.push_front(make_pair(root, 0));
        
        vec_vec_int res;
        pairT n;
        TreeNode* p;
        int level;
        
        while(!nodelist.empty())
        {
            n = nodelist.back();
            nodelist.pop_back();
            p = n.first; level = n.second;
            if (p)
            {
                if (res.size() < level + 1)
                    res.push_back(vector<int>());
                res[level].push_back(p->val);
                nodelist.push_front(make_pair(p->left,  level + 1));
                nodelist.push_front(make_pair(p->right, level + 1));
            }
        }
        return vector<vector<int>> (res.rbegin(), res.rend());
    }