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中避免无效的递归
- 如果当前root等于node,结束递归
- 如果当前的root.val>node.val,往左子树递归,不需要往右子树递归
- 如果当前的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)
比后序迭代简单很多