https://leetcode.com/problems/lowest-common-ancestor-of-deepest-leaves/
Given a rooted binary tree, return the lowest common ancestor of its deepest leaves.
Recall that:
- The node of a binary tree is a leaf if and only if it has no children
- The depth of the root of the tree is 0, and if the depth of a node is
d
, the depth of each of its children isd+1
. - The lowest common ancestor of a set
S
of nodes is the nodeA
with the largest depth such that every node in S is in the subtree with rootA
.
Example 1:
Input: root = [1,2,3] Output: [1,2,3] Explanation: The deepest leaves are the nodes with values 2 and 3. The lowest common ancestor of these leaves is the node with value 1. The answer returned is a TreeNode object (not an array) with serialization "[1,2,3]".
Example 2:
Input: root = [1,2,3,4] Output: [4]
Example 3:
Input: root = [1,2,3,4,5] Output: [2,4,5]
Constraints:
- The given tree will have between 1 and 1000 nodes.
- Each node of the tree will have a distinct value between 1 and 1000.
/**
* 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:
TreeNode* lcaDeepestLeaves(TreeNode* root) {
int depth = caculateDepth(root);
return helper(root, 0, depth);
}
private:
TreeNode* helper(TreeNode* node, int d, const int& depth) {
if (node == nullptr) return nullptr;
if (d == depth) return node;
TreeNode* leftDepthLeaves = helper(node->left, d + 1, depth);
TreeNode* rightDepthLeaves = helper(node->right, d + 1, depth);
if (leftDepthLeaves && rightDepthLeaves) return node;
if (leftDepthLeaves) return leftDepthLeaves;
if (rightDepthLeaves) return rightDepthLeaves;
return nullptr;
}
int caculateDepth(TreeNode* node) {
if (node == nullptr) return -1;
return max(caculateDepth(node->left),
caculateDepth(node->right)) + 1;
}
};