leetcode——第513题——找树左下角的值 / 向下找 同时 向右找

题目：
给定一个二叉树，在树的最后一行找到最左边的值。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
/*******************法一：：层序遍历 迭代法************************/
// public:
    // int findBottomLeftValue(TreeNode* root) {
    //     // 先用层序遍历实现一遍，我觉得我可以自己写出来的得得得
    //     queue<TreeNode*> que;
    //     int result = 0;
    //     if(root == nullptr)
    //     {
    //         return result;
    //     }
    //     que.push(root);
    //     while(!que.empty())
    //     {
    //         int size = que.size();
    //         TreeNode* node = nullptr;
    //         // for(int i=0; i<size; i++)
    //         // {
    //         //     if(i==0)
    //         //     {
    //         //         node = que.front();
    //         //     }
    //         //     TreeNode* temp = que.front();
    //         //     que.pop(); 
    //         //     if(temp->left != nullptr)   que.push(temp->left);
    //         //     if(temp->right != nullptr)  que.push(temp->right);
    //         // }
    //         // if(que.empty())
    //         // {
    //         //     result = node->val;
    //         //     return result;
    //         // }

    //         // 以上可以简化一下
    //         for(int i=0; i<size; i++)
    //         {
    //             TreeNode* node = que.front();
    //             que.pop();
    //             if(i==0)
    //             {
    //                 result = node->val;
    //             }
    //             if(node->left != nullptr)   que.push(node->left);
    //             if(node->right != nullptr)  que.push(node->right);
    //         }
    //     }
    //     return result;
    // }
/**********************法二：：递归法***************************/
private:
    int maxLen = INT_MIN;   // 记录最大深度
    int maxLeftValue;       // 记录最大深度下对应的左

public:
    void traversal(TreeNode* cur,int leftLen)
    {
        // 注意这里leftLen 在每次更新节点后，也会对应更新，是用来记录本节点的最长深度
        // 本节点的最长深度不一定是这个树的最长深度，所以需要不停的更新维护
        if(cur->left == nullptr && cur->right == nullptr)
        {
            // 对于终止条件，当遇到叶子节点就需要终止
            // 这里相当于横向操作，自左向右，找最左
            if(leftLen > maxLen)
            {
                maxLen = leftLen;
                maxLeftValue = cur->val;
            }
            // 既然是终止条件，那么就一定要有 return 语句哇
            return;
        }

        // 这里开始向下递归；找到最大深度的时候，是需要回归的
        if(cur->left != nullptr)
        {
            // 每向下一层，则 深度需要加 1
            leftLen++;
            traversal(cur->left,leftLen);
            leftLen--;
            // 为了保证本层的还是本层的，因此需要回溯 也就是深度做 --
        }
        if(cur->right != nullptr)
        {
            leftLen++;
            traversal(cur->right,leftLen);
            leftLen--;
        }
        return;
    }

    int findBottomLeftValue(TreeNode* root)
    {
        // int result = 0;
        // if(root == nullptr)
        // {
        //     return result;
        // } 
        // traversal(root,0);
        // 因为这里在递归函数中，可以把根节点为空的情况包含进去，
        traversal(root,0);
        return maxLeftValue;
    }

};