leetcode 513 学习笔记（递归、层序遍历）

513. 找树左下角的值

问题描述：传送门

思路：

本地要找出树的最后一行里最左边的值。
很明显，用层序遍历要简单，不建议用递归。

这里还是提供一种思路。

1、递归

首先要是最后一行，然后是最左边的值。

如何判断是最后一行?

就是深度最大的叶子节点一定是最后一行。所以要找深度最大的叶子节点。

那么如何找最左边的呢?

可以使用前序遍历，这样才先优先左边搜索，然后记录深度最大的叶子节点，这集就是树的最后一行最左边的值。

递归三部曲：

① 确定递归函数的参数和返回值

参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。这里就不需要返回值了，所以递归函数的返回类型为void。

本题还需要类里的两个全局变量，maxLen用来记录最大深度，maxleftValue记录最大深度最左节点的数值。

代码如下：

	int maxLen = INT_MIN;   // 全局变量 记录最大深度
	int maxleftValue;       // 全局变量 最大深度最左节点的数值
	void traversal(TreeNode* root, int leftLen)

递归函数的返回值返回最长深度呢？

如果需要遍历整颗树，递归函数就不能有返回值。
如果需要遍历某一条固定路线，递归函数就一定要有返回值！

本题我们是要遍历整个树找到最深的叶子节点,所以递归函数没有返回值。

② 确定终止条件

当遇到叶子节点的时候，就需要统计一下最大的深度了，所以遇到叶子节点来更新最大深度。

代码如下：

	if (root->left == NULL && root->right == NULL) {
	    if (leftLen > maxLen) {
	        maxLen = leftLen;           // 更新最大深度
	        maxleftValue = root->val;   // 最大深度最左面的数值 
	    }
	    return;
	}

③ 确定单层递归的逻辑

在找最大深度的时候，递归的过程中依然要使用回溯，代码如下：

	                    // 中
	if (root->left) {   // 左
	    leftLen++; // 深度加一     
	    traversal(root->left, leftLen);
	    leftLen--; // 回溯，深度减一
	}
	if (root->right) { // 右
	    leftLen++; // 深度加一
	    traversal(root->right, leftLen);
	    leftLen--; // 回溯，深度减一
	}
	return;

完整代码如下：

	class Solution {
	public:
	    int maxLen = INT_MIN;
	    int maxleftValue;
	    void traversal(TreeNode* root, int leftLen) {
	        if (root->left == NULL && root->right == NULL) {
	            if (leftLen > maxLen) {
	                maxLen = leftLen;
	                maxleftValue = root->val;
	            }
	            return;
	        }
	        if (root->left) {
	            leftLen++;
	            traversal(root->left, leftLen);
	            leftLen--; // 回溯
	        }
	        if (root->right) {
	            leftLen++;
	            traversal(root->right, leftLen);
	            leftLen--; // 回溯 
	        }
	        return;
	    }
	    int findBottomLeftValue(TreeNode* root) {
	        traversal(root, 0);
	        return maxleftValue;
	    }
	};

当然回溯的地方可以精简，精简代码如下：

	class Solution {
	public:
	    int maxLen = INT_MIN;
	    int maxleftValue;
	    void traversal(TreeNode* root, int leftLen) {
	        if (root->left == NULL && root->right == NULL) {
	            if (leftLen > maxLen) {
	                maxLen = leftLen;
	                maxleftValue = root->val;
	            }
	            return;
	        }
	        if (root->left) {
	            traversal(root->left, leftLen + 1); // 隐藏着回溯
	        }
	        if (root->right) {
	            traversal(root->right, leftLen + 1); // 隐藏着回溯
	        }
	        return;
	    }
	    int findBottomLeftValue(TreeNode* root) {
	        traversal(root, 0);
	        return maxleftValue;
	    }
	};

2、层序遍历

层序遍历只需要记录最后一行第一个节点的数值就可以了。

代码如下：

	class Solution {
	public:
	    int findBottomLeftValue(TreeNode* root) {
	        queue<TreeNode*> que;
	        if (root != NULL) 
	        	que.push(root);
	        int result = 0;
	        while (!que.empty()) {
	            int size = que.size();
	            for (int i = 0; i < size; i++) {
	                TreeNode* node = que.front();
	                que.pop();
	                if (i == 0) 
	                	result = node->val; 
	                	// 记录最后一行第一个元素
	                if (node->left) 
	                	que.push(node->left);
	                if (node->right) 
	                	que.push(node->right);
	            }
	        }
	        return result;
	    }
	};