Python-Leetcode-二叉树的最近公共祖先（LCA）问题

最近公共祖先（Lowest Common Ancestor，LCA），详见百度百科。一个节点也可以是它自己的祖先。

一次查询

面试题68 - I. 二叉搜索树的最近公共祖先

从树根开始，如果当前节点值大于p和q，那么p和q的公共祖先，一定在当前节点的左子树上。

从树根开始，如果当前节点值小于p和q，那么p和q的公共祖先，一定在当前节点的右子树上。

从树根开始，如果当前节点值介于p和q，那么该节点就是p和q的最近公共节点。

按照上面规则来做：

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        
        if p.val > q.val:
            p,q=q,p #保证左小右大
        while(True):
            if root.val < p.val: #比最小的小
                root =root.right
            elif root.val >q.val:#比最大的大
                root = root.left
            else:
                return root

面试题68 - II. 二叉树的最近公共祖先

上面的题是基于二叉搜索树的，它的左子树和右子树有明显关系。没有关系的时候，就是这道题。我觉得是一样的解题思路。关于树的问题一般都可以转换为递归（因为树本来就是递归描述）。

如果p和q分别在节点的两边，那么该节点就是最近的公共祖先。

p和q都在该节点的左子树，那么继续找该节点的左子树。lowestCommonAncestor(root.left,p,q) ->递归关系

p和q都在该节点的右子树，那么继续找该节点的右子树。

边界问题：return的问题。

（1）如果root为空，那么返回root，若root=p 或者 root=q 那么已经找到，就是root

（2）如果上面两种情况都没有，那么就要继续分别在root的左右子树寻找，如果找到该节点的最左子树（left==None），依旧没有找到，那么说明，p和q在右子树上（返回右子树的情况）。

（3）如果上面两种情况都没有，那么就要继续分别在root的左右子树寻找，如果找到root的最右子树（left==None），依旧没有找到，那么说明，p和q在左子树上（返回左子树的情况）。

（4）如果上面两种情况都没有，那么就要继续分别在root的左右子树寻找，如果找到该节点的左子树和右子树上都返回了节点，那么该节点就是公共祖先。分别位于两侧。

左右子树寻找过程是独立的。

class Solution:
    def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:        
        if not root or root == p or root == q:
            return root 
        left = self.lowestCommonAncestor(root.left,p,q) #左下面继续找
        right = self.lowestCommonAncestor(root.right,p,q) # 右下面继续找

        if not left: #左子树都找完了,依旧不存在
            return right #肯定是在右子树
        if not right: #同上
            return left
        return root # 如果左,右都有返回,那么说明在root的两侧 

---

多次查询

当将查找两个节点的最近公共祖先看做是查询的问题，如果是只求一次，则是单次查询；如果要求多个任意两个结点的最近公共祖先，则相当于是批量查询。上面的查询都是属于一次查询，时间复杂度是O(N)，那么如果是多次查询的话，总体复杂度为O(KN)。扩大了K（次数）倍。因此有了一些其他的算法来解决这个O（KN）的问题。

(1)Tarjan算法   

(2)将查询转换为RMQ问题( Range Maximum/Minimm Query)

(3)倍增法

(4)重链剖分算法

(5)后序遍历

以上五种算法，我只碰到了第三种的一个题。(1)(2)算法可详见此链接。(4)(5)算法没有链接hhh。

(3)倍增法 -> 未了解过的要先看下，稀疏表(SparseTable，ST)算法。

5188. 树节点的第 K 个祖先

代码来自：题解中的@dz-lee

class TreeAncestor:

    def __init__(self, n: int, parent: List[int]):
        self.dp = [[-1 for _ in range(0,20)] for _ in range(0,n)] #n,log2(50000)=20
        # 最深父节点不超过20
        for i in range(0,n): #节点的第1个父节点是parent
            self.dp[i][0] = parent[i]  #dic[节点]=父节点
        
        for j in range(1, 20): #构建2^1,2^2,2^3父节点
            for i in range(n):
                if self.dp[i][j-1] != -1:
                    self.dp[i][j] = self.dp[self.dp[i][j-1]][j-1]

    def getKthAncestor(self, node: int, k: int) -> int:
        for i in range(19, -1, -1):
            if k & (1 << i): ## k = 2^0+2^3,那么先跳到2^3,然后向下找,直到找到最近的.
                node = self.dp[node][i]
                if node == -1:
                    break
        return node