Python 二叉搜索树的最近公共祖先

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

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

例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

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

示例 2:

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

算法逻辑

第一步

找到二叉搜索树中两节点的最近共祖先（也就是节点），其本质上的原理与二叉搜索树的插入相同，但也有一些细节上的不一

二叉搜索树的插入是从根节点开始，向左或者向右进行递推，找到合适的位置后建立新的节点：

若要插入的值小于根节点：

向左递推

若左节点为空那么就在此处建立新节点

若左节点不为空那么就继续递归

若要插入的值大于根节点：

向右递推

若右节点为空那么就在此处建立新节点

若右节点不为空那么就继续递归

    def insert(self, data):
        self.insert_recursion(self.root, data)

    def insert_recursion(self, current, data):
        if data < current.data:
            if current.left is None:
                current.left = tree_node(data)
            else:
                self.insert_recursion(current.left, data)
        else:
            if current.right is None:
                current.right = tree_node(data)
            else:
                self.insert_recursion(current.right, data)

（二叉搜索树插入代码）

第二步

明白了上述逻辑之后，我们就可以想到一个时间复杂度很低的算法

首先定义两个指针（current_0, current_1）都指向二叉树搜索的根节点，随后开始让current_0与current_1分别在二叉树中寻找p和q

一般的，当两个指针都指向同一节点说明该点为p和q的公共节点，但不是最近公共节点，最近公共节点是两指针分开前一步的节点，指针分开后两指针分别指向两个不同的节点，而它们上次所指向的节点为最小公共节点

current_0与current_1在寻找p和q时若都满足判断条件，则继续递归，若不满足，则说明以及找到了最近公共祖先，返回即可

    def find_common_node(self, num_0, num_1):
        result = []
        result.append(self.root.data)
        return self.find_common_node_recursion(self.root, self.root, num_0, num_1, result)

    def find_common_node_recursion(self, current_0, current_1, num_0, num_1, result):
        if num_0 < current_0.data and num_1 < current_1.data:
            result.append(current_0.left.data)  # 随便将一个指针指向节点的值加入列表内，反正非公共节点的时候弹出
            self.find_common_node_recursion(current_0.left, current_1.left, num_0, num_1, result)
        if num_0 > current_0.data and num_1 > current_1.data:
            result.append(current_0.right.data)  # 随便将一个指针指向节点的值加入列表内，反正非公共节点的时候弹出
            self.find_common_node_recursion(current_0.right, current_1.right, num_0, num_1, result)
        return result[len(result) - 1]

（寻找最近公共祖先代码）

完整代码

class tree_node:
    def __init__(self,data):
        self.data = data
        self.left = None
        self.right = None


class binary_tree:
    def __init__(self, data):
        self.root = tree_node(data)

    def insert(self, data):
        self.insert_recursion(self.root, data)

    def insert_recursion(self, current, data):
        if data < current.data:
            if current.left is None:
                current.left = tree_node(data)
            else:
                self.insert_recursion(current.left, data)
        else:
            if current.right is None:
                current.right = tree_node(data)
            else:
                self.insert_recursion(current.right, data)

    def inorder_traversal(self):
        return self.inorder_traversal_recursion(self.root, [])

    def inorder_traversal_recursion(self, current, result):
        if current:
            self.inorder_traversal_recursion(current.left, result)
            result.append(current.data)
            self.inorder_traversal_recursion(current.right, result)
        return result

    def find_common_node(self, num_0, num_1):
        result = []
        result.append(self.root.data)
        return self.find_common_node_recursion(self.root, self.root, num_0, num_1, result)

    def find_common_node_recursion(self, current_0, current_1, num_0, num_1, result):
        if num_0 < current_0.data and num_1 < current_1.data:
            result.append(current_0.left.data)  # 随便将一个指针指向节点的值加入列表内，反正非公共节点的时候弹出
            self.find_common_node_recursion(current_0.left, current_1.left, num_0, num_1, result)
        if num_0 > current_0.data and num_1 > current_1.data:
            result.append(current_0.right.data)  # 随便将一个指针指向节点的值加入列表内，反正非公共节点的时候弹出
            self.find_common_node_recursion(current_0.right, current_1.right, num_0, num_1, result)
        return result[len(result) - 1]



tree_0 = binary_tree(6)
tree_0.insert(2)
tree_0.insert(0)
tree_0.insert(4)
tree_0.insert(3)
tree_0.insert(5)
tree_0.insert(8)
tree_0.insert(7)
tree_0.insert(9)
print(tree_0.inorder_traversal())
print("最小公共祖先为：", tree_0.find_common_node(8, 9))

上述代码中，find_common_node()函数（寻找公共祖先代码）时间复杂度为O(longn)

希望此文章对你有帮助，在评论区留下你的意见和建议（觉得文章内容符合你的心意的话请点个赞支持一下博主，你的鼓励是对博主最大的支持）

当然，最重要的是，自己试试吧，你会做的更好！