Find Bottom Left Tree Value

Given a binary tree, find the leftmost value in the last row of the tree.

Example 1:

Input:

    2
   / \
  1   3

Output:
1

Example 2: 

Input:

        1
       / \
      2   3
     /   / \
    4   5   6
       /
      7

Output:
7
# 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 findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        """
        #递归方法
        ans = []
        def Level_Tree_Travel(level, ans, root):
            if not root:
                return
            if level == len(ans):
                ans.append([])
            if not root.left and not root.right:
                ans[level].append(root.val)
            Level_Tree_Travel(level + 1, ans, root.left)
            Level_Tree_Travel(level + 1, ans, root.right)
        
        Level_Tree_Travel(0, ans, root)
        return ans[len(ans)-1][0]
        """
        #非递归方法
        if not root:
            return
        elem, ans = [[0, root]], [0, root.val]
        while len(elem):
            if elem[0][0] > ans[0] and not elem[0][1].left and not elem[0][1].right:  #level更高的叶子结点
                ans[0], ans[1] = elem[0][0], elem[0][1].val
            if elem[0][1].left:
                elem.append([elem[0][0] + 1, elem[0][1].left])
            if elem[0][1].right:
                elem.append([elem[0][0] + 1, elem[0][1].right])
            del elem[0]
        return ans[1]
        
/**
 * 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 levelTreeTravel(vector<int>& vec, TreeNode* node, int level) {
        if (!node)
            return;
        //if (vec.size() == level)
        //    vec.resize(level + 1);
        if (!node->left && !node->right && level > vec[0] or level == 0){
            vec[0] = level;
            vec[1] = node->val;
        }
        levelTreeTravel(vec, node->left, level + 1);
        levelTreeTravel(vec, node->right, level + 1);
    }
    int findBottomLeftValue(TreeNode* root) {
        vector<int> vec(2, 0);
        levelTreeTravel(vec, root, 0);
        //return vec[vec.size() - 1][0];
        //return (*(vec.end() - 1))[0];
        return vec[1];
    }*/
    int findBottomLeftValue(TreeNode* root) {
        if (!root)
            return -1;
        pair<int, TreeNode*> elem(0, root);
        pair<int, int> ans(0, root->val);
        list<pair<int, TreeNode*>> List;
        List.push_back(elem);
        
        while (!List.empty()) {
            pair<int, TreeNode*> temp = List.front();
            List.pop_front();
            if (temp.first > ans.first && !temp.second->left && !temp.second->right)
                ans = make_pair(temp.first, temp.second->val);

            if (temp.second->left)
                List.push_back(make_pair(temp.first + 1, temp.second->left));
            if (temp.second->right)
                List.push_back(make_pair(temp.first + 1, temp.second->right));
        }
        return ans.second;
    }
};