剑指 Offer 68 - I. 二叉搜索树的最近公共祖先

https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof/
同 235. 二叉搜索树的最近公共祖先 https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/

题目

题目特地强调了二叉搜索树，肯定有解法与二叉搜索树有关

后序遍历法

后序迭代遍历，当碰到结点node的时候，此时迭代栈中的所有结点都是node的祖先节点，通过两次遍历找两组祖先节点，比较即可

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        # 后序迭代遍历到p,q时两个栈
        sp=[]
        sq=[]
        self.visit(root,p,sp)
        self.visit(root,q,sq)

        # 从后往前找到第一个相同的元素
        for i in range(min(len(sp),len(sq))-1,-1,-1):
            # print(sp[i].val,sq[i].val)
            if sp[i]==sq[i]:
                return sp[i] 

    def visit(self,root,node,stack):
        # 后序迭代遍历
        pre = None
        while stack or root:
            if root:
                if root==node:
                    break
                stack.append(root)
                root=root.left
            else:
                root = stack[-1]
                if not root.right or pre == root.right:
                    stack.pop(-1) 
                    pre=root
                    root=None
                else:
                    root=root.right

没有利用到二叉搜索树的性质

先序遍历法

在后序的基础上改进成先序找到p、q结点的路径，然后利用二叉搜索树的性质，在遍历的时候剪枝，最终仍然会找到p、q的路径，然后按照相同的方法比较，这个方法比后序的效率更高一些
最基本的在root中寻找node的路径方法，没有加入剪枝

    def findRoad(self,root,node,road,res):
        if not root:
            return
        if root == node:
            road.append(root)
            res.extend(road.copy())
            return 
        road.append(root)
        self.findRoad(root.left,node,road,res)
        self.findRoad(root.right,node,road,res)
        road.pop()

使用上面的代码进行遍历，其实效果和后序迭代差不多，没有优化多少，只是看起来简洁一些

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        road_p,road_q=[],[] 
        self.findRoad(root,p,[],road_p)
        self.findRoad(root,q,[],road_q)
        
        for i in range(min(len(road_p),len(road_q))-1,-1,-1):
            if road_q[i] == road_p[i]:
                return road_p[i]


    def findRoad(self,root,node,road,res):
        if not root:
            return
        if root == node:
            road.append(root)
            res.extend(road.copy())
            return 
        road.append(root)
        self.findRoad(root.left,node,road,res)
        self.findRoad(root.right,node,road,res)
        road.pop()

考虑二叉搜索树的性质，可以在findRoad中避免无效的递归

1. 如果当前root等于node，结束递归
2. 如果当前的root.val>node.val，往左子树递归，不需要往右子树递归
3. 如果当前的root.val<node.val，往右子树递归，不需要往左子树递归

现在代码变为

    def findRoad(self,root,node,road,res):
        if not root:
            return
        if root == node:
            road.append(root)
            res.extend(road.copy())
            return 
        road.append(root)
        if root.val > node.val:
	        self.findRoad(root.left,node,road,res)
	    else:
	        self.findRoad(root.right,node,road,res)
        road.pop()

最终代码

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        road_p,road_q=[],[] 
        self.findRoad(root,p,[],road_p)
        self.findRoad(root,q,[],road_q)
        
        for i in range(min(len(road_p),len(road_q))-1,-1,-1):
            if road_q[i] == road_p[i]:
                return road_p[i]

    def findRoad(self,root,node,road,res):
        if not root:
            return
        if root == node:
            road.append(root)
            res.extend(road.copy())
            return 
        road.append(root)
        if root.val > node.val:
	        self.findRoad(root.left,node,road,res)
        else:
	        self.findRoad(root.right,node,road,res)
        road.pop()

效率快了很多

递归

给定一颗二叉搜索树root和两个结点p、q，那么pq结点的排列情况有以下：
1 p和q均位于root的左子树，即p.val<root.val and q.val<root.val
2 p和q均位于root的右子树p.val>root.val and q.val>root.val
3 p和q一个在左子树一个在右子树 (p.val<root.val and q.val>root.val ) or (p.val>root.val and q.val<root.val )

当1、2情况时，p和q最近的公共祖先不会是root，应该往root的左右子树走
当3情况时，p和q的公共祖先是root，并且还是最近的

最理想的情况就是3，我们可以唯一确定一个公共结点并返回
下面是伪码

def func(root,p,q):
	if 情况3:
		return root
	else if 情况1:
		return func(root.left,p,q) #往左子树方向找
	else:
		return func(root.right,p,q) #往右子树方向找

画出草图，发现情况1、2会有更具体的细分
最理想的情况是进入若干次1、2情况后，达到情况3
但是有可能存在p是q的祖先，或者q是p的祖先情况，当我们进行若干次迭代后，如果遇到root==p或者root==q的情况时，此时root必定是公共结点，直接返回root即可
更新后的伪代码：

def func(root,p,q):
	if root==p or root==q:
		return root
	if 情况3:
		return root
	else if 情况1:
		return func(root.left,p,q) #往左子树方向找
	else:
		return func(root.right,p,q) #往右子树方向找

通过的代码：

# 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':
        if root == p or root == q:
            return root
        if (p.val<root.val and q.val>root.val ) or (p.val>root.val  and q.val<root.val):
            return root
        elif p.val<root.val and q.val<root.val:
            return self.lowestCommonAncestor(root.left,p,q) 
        else:
            return self.lowestCommonAncestor(root.right,p,q) 

比后序迭代简单很多