mirror of
https://github.com/youngyangyang04/leetcode-master.git
synced 2026-02-02 18:39:09 +08:00
364 lines
12 KiB
Markdown
364 lines
12 KiB
Markdown
<p align="center">
|
||
<a href="https://mp.weixin.qq.com/s/RsdcQ9umo09R6cfnwXZlrQ"><img src="https://img.shields.io/badge/PDF下载-代码随想录-blueviolet" alt=""></a>
|
||
<a href="https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw"><img src="https://img.shields.io/badge/刷题-微信群-green" alt=""></a>
|
||
<a href="https://space.bilibili.com/525438321"><img src="https://img.shields.io/badge/B站-代码随想录-orange" alt=""></a>
|
||
<a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ"><img src="https://img.shields.io/badge/知识星球-代码随想录-blue" alt=""></a>
|
||
</p>
|
||
<p align="center"><strong>欢迎大家<a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
|
||
|
||
|
||
## 235. 二叉搜索树的最近公共祖先
|
||
|
||
链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/
|
||
|
||
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
|
||
|
||
百度百科中最近公共祖先的定义为：“对于有根树 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, 因为根据定义最近公共祖先节点可以为节点本身。
|
||
|
||
|
||
说明:
|
||
|
||
* 所有节点的值都是唯一的。
|
||
* p、q 为不同节点且均存在于给定的二叉搜索树中。
|
||
|
||
## 思路
|
||
|
||
做过[二叉树：公共祖先问题](https://mp.weixin.qq.com/s/n6Rk3nc_X3TSkhXHrVmBTQ)题目的同学应该知道，利用回溯从底向上搜索，遇到一个节点的左子树里有p，右子树里有q，那么当前节点就是最近公共祖先。
|
||
|
||
那么本题是二叉搜索树，二叉搜索树是有序的，那得好好利用一下这个特点。
|
||
|
||
在有序树里，如果判断一个节点的左子树里有p，右子树里有q呢？
|
||
|
||
其实只要从上到下遍历的时候，cur节点是数值在[p, q]区间中则说明该节点cur就是最近公共祖先了。
|
||
|
||
理解这一点，本题就很好解了。
|
||
|
||
和[二叉树：公共祖先问题](https://mp.weixin.qq.com/s/n6Rk3nc_X3TSkhXHrVmBTQ)不同，普通二叉树求最近公共祖先需要使用回溯，从底向上来查找，二叉搜索树就不用了，因为搜索树有序（相当于自带方向），那么只要从上向下遍历就可以了。
|
||
|
||
那么我们可以采用前序遍历（其实这里没有中节点的处理逻辑，遍历顺序无所谓了）。
|
||
|
||
如图所示：p为节点3，q为节点5
|
||
|
||
|
||
|
||
可以看出直接按照指定的方向，就可以找到节点4，为最近公共祖先，而且不需要遍历整棵树，找到结果直接返回！
|
||
|
||
|
||
递归三部曲如下：
|
||
|
||
* 确定递归函数返回值以及参数
|
||
|
||
参数就是当前节点，以及两个结点 p、q。
|
||
|
||
返回值是要返回最近公共祖先，所以是TreeNode * 。
|
||
|
||
代码如下：
|
||
|
||
```
|
||
TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q)
|
||
```
|
||
|
||
* 确定终止条件
|
||
|
||
遇到空返回就可以了，代码如下：
|
||
|
||
```
|
||
if (cur == NULL) return cur;
|
||
```
|
||
|
||
其实都不需要这个终止条件，因为题目中说了p、q 为不同节点且均存在于给定的二叉搜索树中。也就是说一定会找到公共祖先的，所以并不存在遇到空的情况。
|
||
|
||
* 确定单层递归的逻辑
|
||
|
||
在遍历二叉搜索树的时候就是寻找区间[p->val, q->val]（注意这里是左闭又闭）
|
||
|
||
那么如果 cur->val 大于 p->val，同时 cur->val 大于q->val，那么就应该向左遍历（说明目标区间在左子树上）。
|
||
|
||
**需要注意的是此时不知道p和q谁大，所以两个都要判断**
|
||
|
||
代码如下：
|
||
|
||
```C++
|
||
if (cur->val > p->val && cur->val > q->val) {
|
||
TreeNode* left = traversal(cur->left, p, q);
|
||
if (left != NULL) {
|
||
return left;
|
||
}
|
||
}
|
||
```
|
||
|
||
**细心的同学会发现，在这里调用递归函数的地方，把递归函数的返回值left，直接return**。
|
||
|
||
|
||
在[二叉树：公共祖先问题](https://mp.weixin.qq.com/s/n6Rk3nc_X3TSkhXHrVmBTQ)中，如果递归函数有返回值，如何区分要搜索一条边，还是搜索整个树。
|
||
|
||
搜索一条边的写法：
|
||
|
||
```
|
||
if (递归函数(root->left)) return ;
|
||
|
||
if (递归函数(root->right)) return ;
|
||
```
|
||
|
||
搜索整个树写法：
|
||
|
||
```
|
||
left = 递归函数(root->left);
|
||
right = 递归函数(root->right);
|
||
left与right的逻辑处理;
|
||
```
|
||
|
||
本题就是标准的搜索一条边的写法，遇到递归函数的返回值，如果不为空，立刻返回。
|
||
|
||
|
||
如果 cur->val 小于 p->val，同时 cur->val 小于 q->val，那么就应该向右遍历（目标区间在右子树）。
|
||
|
||
```
|
||
if (cur->val < p->val && cur->val < q->val) {
|
||
TreeNode* right = traversal(cur->right, p, q);
|
||
if (right != NULL) {
|
||
return right;
|
||
}
|
||
}
|
||
```
|
||
|
||
剩下的情况，就是cur节点在区间（p->val <= cur->val && cur->val <= q->val）或者 （q->val <= cur->val && cur->val <= p->val）中，那么cur就是最近公共祖先了，直接返回cur。
|
||
|
||
代码如下：
|
||
```
|
||
return cur;
|
||
|
||
```
|
||
|
||
那么整体递归代码如下:
|
||
|
||
```C++
|
||
class Solution {
|
||
private:
|
||
TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q) {
|
||
if (cur == NULL) return cur;
|
||
// 中
|
||
if (cur->val > p->val && cur->val > q->val) { // 左
|
||
TreeNode* left = traversal(cur->left, p, q);
|
||
if (left != NULL) {
|
||
return left;
|
||
}
|
||
}
|
||
|
||
if (cur->val < p->val && cur->val < q->val) { // 右
|
||
TreeNode* right = traversal(cur->right, p, q);
|
||
if (right != NULL) {
|
||
return right;
|
||
}
|
||
}
|
||
return cur;
|
||
}
|
||
public:
|
||
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
|
||
return traversal(root, p, q);
|
||
}
|
||
};
|
||
```
|
||
|
||
精简后代码如下：
|
||
|
||
```C++
|
||
class Solution {
|
||
public:
|
||
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
|
||
if (root->val > p->val && root->val > q->val) {
|
||
return lowestCommonAncestor(root->left, p, q);
|
||
} else if (root->val < p->val && root->val < q->val) {
|
||
return lowestCommonAncestor(root->right, p, q);
|
||
} else return root;
|
||
}
|
||
};
|
||
```
|
||
|
||
## 迭代法
|
||
|
||
对于二叉搜索树的迭代法，大家应该在[二叉树：二叉搜索树登场！](https://mp.weixin.qq.com/s/vsKrWRlETxCVsiRr8v_hHg)就了解了。
|
||
|
||
利用其有序性，迭代的方式还是比较简单的，解题思路在递归中已经分析了。
|
||
|
||
迭代代码如下：
|
||
|
||
```C++
|
||
class Solution {
|
||
public:
|
||
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
|
||
while(root) {
|
||
if (root->val > p->val && root->val > q->val) {
|
||
root = root->left;
|
||
} else if (root->val < p->val && root->val < q->val) {
|
||
root = root->right;
|
||
} else return root;
|
||
}
|
||
return NULL;
|
||
}
|
||
};
|
||
```
|
||
|
||
灵魂拷问：是不是又被简单的迭代法感动到痛哭流涕？
|
||
|
||
## 总结
|
||
|
||
对于二叉搜索树的最近祖先问题，其实要比[普通二叉树公共祖先问题](https://mp.weixin.qq.com/s/n6Rk3nc_X3TSkhXHrVmBTQ)简单的多。
|
||
|
||
不用使用回溯，二叉搜索树自带方向性，可以方便的从上向下查找目标区间，遇到目标区间内的节点，直接返回。
|
||
|
||
最后给出了对应的迭代法，二叉搜索树的迭代法甚至比递归更容易理解，也是因为其有序性（自带方向性），按照目标区间找就行了。
|
||
|
||
|
||
## 其他语言版本
|
||
|
||
|
||
Java：
|
||
```java
|
||
class Solution {
|
||
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
|
||
while (true) {
|
||
if (root.val > p.val && root.val > q.val) {
|
||
root = root.left;
|
||
} else if (root.val < p.val && root.val < q.val) {
|
||
root = root.right;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return root;
|
||
}
|
||
}
|
||
```
|
||
|
||
Python：
|
||
```python
|
||
# 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 not root: return root //中
|
||
if root.val >p.val and root.val > q.val:
|
||
return self.lowestCommonAncestor(root.left,p,q) //左
|
||
elif root.val < p.val and root.val < q.val:
|
||
return self.lowestCommonAncestor(root.right,p,q) //右
|
||
else: return root
|
||
```
|
||
Go：
|
||
> BSL法
|
||
|
||
```go
|
||
/**
|
||
* Definition for a binary tree node.
|
||
* type TreeNode struct {
|
||
* Val int
|
||
* Left *TreeNode
|
||
* Right *TreeNode
|
||
* }
|
||
*/
|
||
//利用BSL的性质（前序遍历有序）
|
||
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
|
||
if root==nil{return nil}
|
||
if root.Val>p.Val&&root.Val>q.Val{//当前节点的值大于给定的值，则说明满足条件的在左边
|
||
return lowestCommonAncestor(root.Left,p,q)
|
||
}else if root.Val<p.Val&&root.Val<q.Val{//当前节点的值小于各点的值，则说明满足条件的在右边
|
||
return lowestCommonAncestor(root.Right,p,q)
|
||
}else {return root}//当前节点的值在给定值的中间（或者等于），即为最深的祖先
|
||
}
|
||
```
|
||
|
||
> 普通法
|
||
|
||
```go
|
||
/**
|
||
* Definition for a binary tree node.
|
||
* type TreeNode struct {
|
||
* Val int
|
||
* Left *TreeNode
|
||
* Right *TreeNode
|
||
* }
|
||
*/
|
||
//递归会将值层层返回
|
||
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
|
||
//终止条件
|
||
if root==nil||root.Val==p.Val||root.Val==q.Val{return root}//最后为空或者找到一个值时，就返回这个值
|
||
//后序遍历
|
||
findLeft:=lowestCommonAncestor(root.Left,p,q)
|
||
findRight:=lowestCommonAncestor(root.Right,p,q)
|
||
//处理单层逻辑
|
||
if findLeft!=nil&&findRight!=nil{return root}//说明在root节点的两边
|
||
if findLeft==nil{//左边没找到，就说明在右边找到了
|
||
return findRight
|
||
}else {return findLeft}
|
||
}
|
||
```
|
||
|
||
JavaScript版本：
|
||
1. 使用递归的方法
|
||
```javascript
|
||
var lowestCommonAncestor = function(root, p, q) {
|
||
// 使用递归的方法
|
||
// 1. 使用给定的递归函数lowestCommonAncestor
|
||
// 2. 确定递归终止条件
|
||
if(root === null) {
|
||
return root;
|
||
}
|
||
if(root.val>p.val&&root.val>q.val) {
|
||
// 向左子树查询
|
||
let left = lowestCommonAncestor(root.left,p,q);
|
||
return left !== null&&left;
|
||
}
|
||
if(root.val<p.val&&root.val<q.val) {
|
||
// 向右子树查询
|
||
let right = lowestCommonAncestor(root.right,p,q);
|
||
return right !== null&&right;
|
||
}
|
||
return root;
|
||
};
|
||
```
|
||
2. 使用迭代的方法
|
||
```javascript
|
||
var lowestCommonAncestor = function(root, p, q) {
|
||
// 使用迭代的方法
|
||
while(root) {
|
||
if(root.val>p.val&&root.val>q.val) {
|
||
root = root.left;
|
||
}else if(root.val<p.val&&root.val<q.val) {
|
||
root = root.right;
|
||
}else {
|
||
return root;
|
||
}
|
||
|
||
}
|
||
return null;
|
||
};
|
||
```
|
||
|
||
|
||
|
||
-----------------------
|
||
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
|
||
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
|
||
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
|
||
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码.jpg width=450> </img></div>
|