LeetCode 1123. 最深叶节点的最近公共祖先:DFS

【LetMeFly】1123.最深叶节点的最近公共祖先

力扣题目链接:https://leetcode.cn/problems/lowest-common-ancestor-of-deepest-leaves/

给你一个有根节点 root 的二叉树,返回它 最深的叶节点的最近公共祖先

回想一下:

  • 叶节点 是二叉树中没有子节点的节点
  • 树的根节点的 深度0,如果某一节点的深度为 d,那它的子节点的深度就是 d+1
  • 如果我们假定 A 是一组节点 S最近公共祖先S 中的每个节点都在以 A 为根节点的子树中,且 A 的深度达到此条件下可能的最大值。

示例 1:

复制代码
输入:root = [3,5,1,6,2,0,8,null,null,7,4]
输出:[2,7,4]
解释:我们返回值为 2 的节点,在图中用黄色标记。
在图中用蓝色标记的是树的最深的节点。
注意,节点 6、0 和 8 也是叶节点,但是它们的深度是 2 ,而节点 7 和 4 的深度是 3 。

示例 2:

复制代码
输入:root = [1]
输出:[1]
解释:根节点是树中最深的节点,它是它本身的最近公共祖先。

示例 3:

复制代码
输入:root = [0,1,3,null,2]
输出:[2]
解释:树中最深的叶节点是 2 ,最近公共祖先是它自己。

提示:

  • 树中的节点数将在 [1, 1000] 的范围内。
  • 0 <= Node.val <= 1000
  • 每个节点的值都是 独一无二 的。

注意: 本题与力扣 865 重复:https://leetcode-cn.com/problems/smallest-subtree-with-all-the-deepest-nodes/

方法一:深度优先搜索(DFS)

们把最深的叶节点的最近公共祖先,称之为 lca \textit{lca} lca节点。

编写一个函数dfs(root),返回以root为根的子树的{lca, 深度}

  • 如果左子树更深,则返回{左子的lac, 左子深度 + 1}

  • 如果右子树更深,则返回{右子的lac, 右子深度 + 1}

  • 否则(左右子树深度相同),则返回{root,左子深度 + 1}

  • 时间复杂度 O ( n ) O(n) O(n),其中 n n n为二叉树节点个数

  • 空间复杂度 O ( n ) O(n) O(n)

AC代码

C++

cpp 复制代码
typedef pair<TreeNode*, int> pti;
class Solution {
private:
    pti dfs(TreeNode* root) {
        if (!root) {
            return {nullptr, 0};
        }
        pti left = dfs(root->left);
        pti right = dfs(root->right);
        if (left.second == right.second) {
            return {root, left.second + 1};
        }
        else if (left.second < right.second) {
            return {right.first, right.second + 1};
        }
        else {
            return {left.first, left.second + 1};
        }
    }
public:
    TreeNode* lcaDeepestLeaves(TreeNode* root) {
        return dfs(root).first;
    }
};

Python

python 复制代码
# from typing import Optional

# # Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution:
    def dfs(self, root: Optional[TreeNode]):
        if not root:
            return [None, 0]
        left = self.dfs(root.left)
        right = self.dfs(root.right)
        if left[1] == right[1]:
            return [root, left[1] + 1]
        elif left[1] < right[1]:
            return [right[0], right[1] + 1]
        else:
            return [left[0], left[1] + 1]
    
    def lcaDeepestLeaves(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        return self.dfs(root)[0]

同步发文于CSDN,原创不易,转载经作者同意后请附上原文链接哦~

Tisfy:https://letmefly.blog.csdn.net/article/details/132725441

相关推荐
C++ 老炮儿的技术栈17 分钟前
手动实现strcpy
c语言·开发语言·c++·算法·visual studio
倔强的石头_1 小时前
【数据结构与算法】利用堆结构高效解决TopK问题
后端·算法
倔强的石头_1 小时前
【数据结构与算法】详解二叉树下:实践篇————通过链式结构深入理解并实现二叉树
后端·算法
哎写bug的程序员1 小时前
leetcode复盘(1)
算法·leetcode·职场和发展
风靡晚1 小时前
用于汽车毫米波雷达的四维高分辨率点云图像
人工智能·算法·机器学习·计算机视觉·汽车·信息与通信·信号处理
简简单单做算法2 小时前
基于FD-MIMO技术的雷达通信一体化系统波形设计matlab模拟与仿真
算法
遥不可及3872 小时前
动态规划(DP)从入门到精通:原理详解与经典问题解析
java·算法
小马敲马2 小时前
[3.4] 集合通信 理论+代码
开发语言·c++·人工智能·算法·性能优化
麦兜*2 小时前
【为什么InnoDB用B+树?从存储结构到索引设计深度解析】
java·数据结构·spring boot·b树·mysql·算法·数据库架构
lboverfys2 小时前
动态规划之爬楼梯(二)
算法·动态规划