Beats 100%, Simple approach Java solution
Intuition\n Describe your first thoughts on how to solve this problem. \nDFS is used to traverse the tree. We calculate the level of the current node. If the no
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nDFS is used to traverse the tree. We calculate the level of the current node. If the node being visited is a leaf node, then we store the level(lvl) of that node and its value(val). \nIf a leaf node with more depth than the previous recorded leaf node is  found, we update the level(lvl)  and value(val).\nThis gives the required result stored in the variable val.\n# Approach\n<!-- Describe your approach to solving the problem. -->\n**Depth-First Traversal:**\n    The code uses a depth-first traversal approach to visit each node in the binary tree.\n\n**Recursive Function (fn):**\n    The recursive function fn traverses the binary tree in a depth-first manner.\nIt keeps track of the current level (clvl) of the node being visited.\n\n**Finding the Leftmost Node at the Bottom Level:**\n    As the tree is traversed, whenever a leaf node (a node with no children) is encountered, the code checks if its level (clvl) is greater than the previously recorded lowest level (lvl).\n    If it is, it updates the lowest level (lvl) with the current level (clvl) and records the value of the leaf node (root.val) a**Bold**s the leftmost node value (v).\n\n# Complexity\n- Time complexity:O(n) since complete traversal of the tree is done\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:If we don\u2019t consider the size of the stack for function calls then O(1) otherwise O(h) where h is the height of the tree. \n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n *     int val;\n *     TreeNode left;\n *     TreeNode right;\n *     TreeNode() {}\n *     TreeNode(int val) { this.val = val; }\n *     TreeNode(int val, TreeNode left, TreeNode right) {\n *         this.val = val;\n *         this.left = left;\n *         this.right = right;\n *     }\n * }\n */\nclass Solution {\n    int lvl=-1,v=-1;\n    public int findBottomLeftValue(TreeNode root) {\n        fn(root,-1);\n        return v;\n    }\n    void fn(TreeNode root,int clvl)\n    {\n        ++clvl;\n        if(root.left==null && root.right==null && clvl>lvl)\n            {\n                lvl=clvl;\n                v=root.val;\n            }\n        if(root.left!=null)\n        {\n            fn(root.left,clvl);\n        } \n        if(root.right!=null)\n        {\n            fn(root.right,clvl);\n        }\n        return;\n    }\n}\n```
['Depth-First Search', 'Recursion', 'Java']