Lowest Common Ancestor of a Binary Search Tree

Problem

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.

According to the definition of LCA on Wikipedia: "The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself)."

Example 1:

复制代码
Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
Output: 6
Explanation: The LCA of nodes 2 and 8 is 6.

Example 2:

复制代码
Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
Output: 2
Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

Example 3:

复制代码
Input: root = [2,1], p = 2, q = 1
Output: 2

Intuition

The goal is to find the lowest common ancestor (LCA) of two given nodes in a binary search tree (BST). The intuition is to exploit the properties of a BST, where nodes in the left subtree are smaller than the root, and nodes in the right subtree are larger than the root. By comparing the values of the nodes p and q with the value of the current root, we can determine the location of the LCA.

Approach

Traversal:

Start with the root of the BST.

While traversing the tree:

If both p and q are greater than the current root's value, move to the right subtree.

If both p and q are smaller than the current root's value, move to the left subtree.

If the current root's value is between p and q, or if it is equal to either p or q, then the current root is the LCA. Return the current root.

Return Result:

Return the final result, which is the lowest common ancestor of p and q.

Complexity

  • Time complexity:

The time complexity is O(h), where h is the height of the binary search tree. In the average case, for a balanced BST, the height is O(log n), making the time complexity O(log n). However, in the worst case of an unbalanced tree, the height could be O(n), resulting in a time complexity of O(n).

  • Space complexity:

The space complexity is O(1) since no additional data structures are used that scale with the input size. The algorithm uses a constant amount of space to store the current root and temporary variables.

Code

复制代码
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        while root:
            if root.val < p.val and root.val < q.val:
                root = root.right
            
            elif root.val > p.val and root.val > q.val:
                root = root.left
            
            else:
                return root
        return None
相关推荐
python_tty15 分钟前
排序算法(一):冒泡排序
数据结构·算法·排序算法
皮蛋sol周1 小时前
嵌入式学习C语言(八)二维数组及排序算法
c语言·学习·算法·排序算法
森焱森1 小时前
单片机中 main() 函数无 while 循环的后果及应对策略
c语言·单片机·算法·架构·无人机
平和男人杨争争2 小时前
机器学习12——支持向量机中
算法·机器学习·支持向量机
10岁的博客2 小时前
代码编程:一场思维与创造力的革命
开发语言·算法
Aczone282 小时前
嵌入式 数据结构学习 (六) 树、哈希表与内核链表
数据结构·学习·算法
定偶2 小时前
进制转换小题
c语言·开发语言·数据结构·算法
体系结构论文研讨会3 小时前
多项式环及Rq的含义
算法
智驱力人工智能3 小时前
极端高温下的智慧出行:危险检测与救援
人工智能·算法·安全·行为识别·智能巡航·高温预警·高温监测
森焱森3 小时前
60 美元玩转 Li-Fi —— 开源 OpenVLC 平台入门(附 BeagleBone Black 驱动简单解析)
c语言·单片机·算法·架构·开源