二叉搜索树的最近公共祖先：递归与迭代解法全面解析

二叉搜索树的最近公共祖先：递归与迭代解法全面解析

引用

CSDN

1.

https://blog.csdn.net/CCIEHL/article/details/141710474

在本篇文章中，我们将详细解读力扣第235题“二叉搜索树的最近公共祖先”。通过学习本篇文章，读者将掌握如何在二叉搜索树中找到两个节点的最近公共祖先，并了解相关的复杂度分析和模拟面试问答。每种方法都将配以详细的解释，以便于理解。

问题描述

力扣第235题“二叉搜索树的最近公共祖先”描述如下：

给定一个二叉搜索树，找到该树中两个指定节点的最近公共祖先。

最近公共祖先的定义为：对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。

示例:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2，因为根据定义最近公共祖先节点可以为节点本身。

解题思路

方法一：递归法

1. 初步分析 ：

   • 在二叉搜索树中，左子树的所有节点值都小于根节点，右子树的所有节点值都大于根节点。利用这一特性，可以通过递归查找两个节点 p 和 q 的最近公共祖先。

2. 步骤 ：

   • 如果 p 和 q 都比当前节点的值小，则最近公共祖先在当前节点的左子树中。
   • 如果 p 和 q 都比当前节点的值大，则最近公共祖先在当前节点的右子树中。
   • 否则，当前节点就是 p 和 q 的最近公共祖先。

代码实现

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def lowestCommonAncestor(root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
    if not root:
        return None
    
    # 如果 p 和 q 都小于当前节点值，向左子树查找
    if p.val < root.val and q.val < root.val:
        return lowestCommonAncestor(root.left, p, q)
    
    # 如果 p 和 q 都大于当前节点值，向右子树查找
    if p.val > root.val and q.val > root.val:
        return lowestCommonAncestor(root.right, p, q)
    
    # 如果 p 和 q 一个小于当前节点，一个大于当前节点，当前节点即为最近公共祖先
    return root

# 测试案例
root = TreeNode(6, TreeNode(2, TreeNode(0), TreeNode(4, TreeNode(3), TreeNode(5))), TreeNode(8, TreeNode(7), TreeNode(9)))
p = root.left  # 节点 2
q = root.right  # 节点 8
print(lowestCommonAncestor(root, p, q).val)  # 输出: 6

p = root.left  # 节点 2
q = root.left.right  # 节点 4
print(lowestCommonAncestor(root, p, q).val)  # 输出: 2

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

方法二：迭代法

1. 初步分析 ：

   • 与递归方法相似，通过迭代的方式在树中查找 p 和 q 的最近公共祖先，逐步向下遍历树直到找到最近公共祖先为止。

2. 步骤 ：

   • 从根节点开始，迭代地比较 p 和 q 的值与当前节点的值，直到找到最近公共祖先。

代码实现

def lowestCommonAncestor(root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
    while root:
        # 如果 p 和 q 都小于当前节点值，向左子树查找
        if p.val < root.val and q.val < root.val:
            root = root.left
        # 如果 p 和 q 都大于当前节点值，向右子树查找
        elif p.val > root.val and q.val > root.val:
            root = root.right
        else:
            # 如果 p 和 q 一个小于当前节点，一个大于当前节点，当前节点即为最近公共祖先
            return root

# 测试案例
root = TreeNode(6, TreeNode(2, TreeNode(0), TreeNode(4, TreeNode(3), TreeNode(5))), TreeNode(8, TreeNode(7), TreeNode(9)))
p = root.left  # 节点 2
q = root.right  # 节点 8
print(lowestCommonAncestor(root, p, q).val)  # 输出: 6

p = root.left  # 节点 2
q = root.left.right  # 节点 4
print(lowestCommonAncestor(root, p, q).val)  # 输出: 2

• 1

• 2

• 3

• 4

• 5

• 6

• 7

• 8

• 9

• 10

• 11

• 12

• 13

• 14

• 15

• 16

• 17

• 18

• 19

• 20

• 21

• 时间复杂度 ：

  • 递归法：O(H)，其中 H 是树的高度。最坏情况下，可能需要遍历树的所有节点。
  • 迭代法：O(H)，同样需要遍历树的节点，直到找到最近公共祖先。

• 空间复杂度 ：

  • 递归法：O(H)，递归调用栈的深度取决于树的高度。
  • 迭代法：O(1)，只使用了少量的指针变量。

模拟面试问答

问题 1 ：你能描述一下如何解决这个问题的思路吗？

回答 ：我们可以利用二叉搜索树的特性来解决这个问题。在二叉搜索树中，左子树的所有节点值都小于根节点，右子树的所有节点值都大于根节点。通过比较 p 和 q 的值与当前节点的值，可以确定最近公共祖先的位置。如果 p 和 q 都小于当前节点的值，那么最近公共祖先在左子树中；如果 p 和 q 都大于当前节点的值，那么最近公共祖先在右子树中；否则，当前节点即为最近公共祖先。

问题 2 ：为什么选择使用递归或迭代的方法来解决这个问题？

回答 ：递归和迭代的方法都能够利用二叉搜索树的特性高效地找到最近公共祖先。递归方法代码简洁直观，适合于理解问题的核心逻辑；迭代方法则避免了递归带来的栈空间消耗，更加节省内存。两种方法的时间复杂度相同，选择哪种方法取决于具体的需求和场景。

问题 3 ：你的算法的时间复杂度和空间复杂度是多少？

回答 ：两种方法的时间复杂度都是 O(H)，其中 H 是树的高度。在最坏情况下（例如链式树），需要遍历所有节点。递归方法的空间复杂度为 O(H)，因为递归调用栈的深度与树的高度相关；迭代方法的空间复杂度为 O(1)，只需要少量的指针变量。

问题 4 ：在代码中如何处理边界情况？

回答 ：对于空树或只有一个节点的树，代码处理简单，直接返回当前节点或 None。对于 p 和 q 是同一节点的情况，代码也能够正确返回该节点作为最近公共祖先。代码通过二叉搜索树的特性，保证了所有可能的情况都能正确处理。

问题 5 ：你能解释一下为什么二叉搜索树的特性在这个问题中如此重要吗？

回答 ：二叉搜索树的特性决定了每个节点的左子树值都小于节点值，右子树值都大于节点值。这使得在查找最近公共祖先时，我们可以根据 p 和 q 的值相对于当前节点的大小关系来快速定位公共祖先的位置，而不需要遍历整个树。这一特性极大地提高了查找效率。

问题 6 ：在代码中如何确保返回的结果是正确的？

回答 ：通过每一步的比较操作，确保 p 和 q 的值相对于当前节点的大小关系得到正确处理。如果 p 和 q 的值分别位于当前节点的两侧，或者其中一个值等于当前节点的值，则当前节点即为最近公共祖先。代码通过这种逻辑保证了返回结果的正确性。

问题 7 ：你能举例说明在面试中如何回答优化问题吗？

回答 ：在面试中，如果被问到如何优化算法，我会首先分析当前算法的时间复杂度和空间复杂度。由于算法的时间复杂度已经是 O(H)，即使在最坏情况下也只需要遍历一次树，进一步优化的空间有限。可以讨论如何减少递归调用带来的栈空间消耗（如果采用递归方法），或如何在极端情况下（例如链式树）优化树结构以减少树的高度。

问题 8 ：如何验证代码的正确性？

回答 ：通过编写详细的测试用例，涵盖所有可能的树结构，如完全二叉树、不平衡二叉树、单节点树等，确保每个测试用例的结果都符合预期。此外，还可以通过手工推演树的遍历过程，验证代码逻辑的正确性。

问题 9 ：你能解释一下解决“二叉搜索树的最近公共祖先”问题的重要性吗？

回答 ：解决“二叉搜索树的最近公共祖先”问题展示了对树形数据结构的理解，尤其是二叉搜索树的特性。最近公共祖先问题是树形结构中非常经典的问题，通过掌握这种问题的解决方法，可以提高对树形结构的理解，并为处理更复杂的树形数据结构问题打下基础。

问题 10 ：在处理大数据集时，算法的性能如何？

回答 ：由于算法的时间复杂度为 O(H)，在高度平衡的二叉搜索树中，性能表现良好。然而，如果树的高度接近节点数（例如链式树），性能可能下降。迭代方法通过节省空间，在处理大数据集时更加稳定，并且不会因为递归深度过大而导致栈溢出。

总结

本文详细解读了力扣第235题“二叉搜索树的最近公共祖先”，通过使用递归法和迭代法高效地查找二叉搜索树中两个节点的最近公共祖先，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。