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 = Noneclass Solution(object):

# dfs recursivelydef levelOrderBottom1(self, root):    res = []    self.dfs(root, 0, res)    return resdef 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 + stackdef 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 = Noneclass 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());    }