题目## 题目## 题目
题目的主要信息：
- 给定一棵二叉树以及这棵树上的两个节点对应的val值 o1 和 o2，请找到 o1 和 o2 的最近公共祖先节点
- 二叉树非空，且每个节点值均不同
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：路径比较法(推荐使用)
知识点：深度优先搜索（dfs）
深度优先搜索一般用于树或者图的遍历，其他有分支的（如二维矩阵）也适用。它的原理是从初始点开始，一直沿着同一个分支遍历，直到该分支结束，然后回溯到上一级继续沿着一个分支走到底，如此往复，直到所有的节点都有被访问到。
思路：
既然要找到二叉树中两个节点的最近公共祖先，那我们可以考虑先找到两个节点全部祖先，可以得到从根节点到目标节点的路径，然后依次比较路径得出谁是最近的祖先。
找到两个节点的所在可以深度优先搜索遍历二叉树所有节点进行查找。
具体做法：
- step 1：利用dfs求得根节点到两个目标节点的路径：每次选择二叉树的一棵子树往下找，同时路径数组增加这个遍历的节点值。
- step 2：一旦遍历到了叶子节点也没有，则回溯到父节点，寻找其他路径，回溯时要去掉数组中刚刚加入的元素。
- step 3：然后遍历两条路径数组，依次比较元素值。
- step 4：找到两条路径第一个不相同的节点即是最近公共祖先。
图示：
Java实现代码：
import java.util.*;
public class Solution {
//记录是否找到到o的路径
public boolean flag = false;
//求得根节点到目标节点的路径
public void dfs(TreeNode root, ArrayList<Integer> path, int o){
if(flag || root == null)
return;
path.add(root.val);
//节点值都不同，可以直接用值比较
if(root.val == o){
flag = true;
return;
}
//dfs遍历查找
dfs(root.left, path, o);
dfs(root.right, path, o);
//找到
if(flag)
return;
//回溯
path.remove(path.size() - 1);
}
public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
ArrayList<Integer> path1 = new ArrayList<Integer>();
ArrayList<Integer> path2 = new ArrayList<Integer>();
//求根节点到两个节点的路径
dfs(root, path1, o1);
//重置flag，查找下一个
flag = false;
dfs(root, path2, o2);
int res = 0;
//比较两个路径，找到第一个不同的点
for(int i = 0; i < path1.size() && i < path2.size(); i++){
int x = path1.get(i);
int y = path2.get(i);
if(x == y)
//最后一个相同的节点就是最近公共祖先
res = x;
else
break;
}
return res;
}
}
C++实现代码：
class Solution {
public:
//记录是否找到到o的路径
bool flag = false;
//求得根节点到目标节点的路径
void dfs(TreeNode* root, vector<int>& path, int o){
if(flag || root == NULL)
return;
path.push_back(root->val);
//节点值都不同，可以直接用值比较
if(root->val == o){
flag = true;
return;
}
//dfs遍历查找
dfs(root->left, path, o);
dfs(root->right, path, o);
//找到
if(flag)
return;
//该子树没有，回溯
path.pop_back();
}
int lowestCommonAncestor(TreeNode* root, int o1, int o2) {
vector<int> path1, path2;
//求根节点到两个节点的路径
dfs(root, path1, o1);
//重置flag，查找下一个
flag = false;
dfs(root, path2, o2);
int res;
//比较两个路径，找到第一个不同的点
for(int i = 0; i < path1.size() && i < path2.size(); i++){
if(path1[i] == path2[i])
//最后一个相同的节点就是最近公共祖先
res = path1[i];
else
break;
}
return res;
}
};
Python实现代码
class Solution:
# 记录是否找到到o的路径
flag = False
# 求得根节点到目标节点的路径
def dfs(self, root: TreeNode, path: List[int], o: int):
if self.flag or not root:
return
path.append(root.val)
# 节点值都不同，可以直接用值比较
if root.val == o:
self.flag = True
return
# dfs遍历查找
self.dfs(root.left, path, o)
self.dfs(root.right, path, o)
#找到
if self.flag:
return
# 该子树没有，回溯
path.pop()
def lowestCommonAncestor(self , root: TreeNode, o1: int, o2: int) -> int:
path1, path2 = [], []
# 求根节点到两个节点的路径
self.dfs(root, path1, o1)
# 重置flag，查找下一个
self.flag = False
self.dfs(root, path2, o2)
i = 0
res = None
# 比较两个路径，找到第一个不同的点
while i < len(path1) and i < len(path2):
if path1[i] == path2[i]:
# 最后一个相同的节点就是最近公共祖先
res = path1[i]
i += 1
else:
break
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为二叉树节点数，递归遍历二叉树每一个节点求路径，后续又遍历路径
- 空间复杂度： O ( n ) O(n) O(n)，最坏情况二叉树化为链表，深度为 n n n，递归栈深度和路径数组为 n n n
方法二：递归（扩展思路）
知识点：二叉树递归
递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这是使用递归的关键。
而二叉树的递归，则是将某个节点的左子树、右子树看成一颗完整的树，那么对于子树的访问或者操作就是对于原树的访问或者操作的子问题，因此可以自我调用函数不断进入子树。
思路：
我们也可以讨论几种情况：
- step 1：如果o1和o2中的任一个和root匹配，那么root就是最近公共祖先。
- step 2：如果都不匹配，则分别递归左、右子树。
- step 3：如果有一个节点出现在左子树，并且另一个节点出现在右子树，则root就是最近公共祖先.
- step 4：如果两个节点都出现在左子树，则说明最低公共祖先在左子树中，否则在右子树。
- step 5：继续递归左、右子树，直到遇到step1或者step3的情况。
Java实现代码：
import java.util.*;
public class Solution {
public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
//该子树没找到，返回-1
if(root == null)
return -1;
//该节点是其中某一个节点
if(root.val == o1 || root.val == o2)
return root.val;
//左子树寻找公共祖先
int left = lowestCommonAncestor(root.left, o1, o2);
//右子树寻找公共祖先
int right = lowestCommonAncestor(root.right, o1, o2);
//左子树为没找到，则在右子树中
if(left == -1)
return right;
//右子树没找到，则在左子树中
if(right == -1)
return left;
//否则是当前节点
return root.val;
}
}
C++实现代码：
class Solution {
public:
int lowestCommonAncestor(TreeNode* root, int o1, int o2) {
//该子树没找到，返回-1
if(root == NULL)
return -1;
//该节点是其中某一个节点
if(root->val == o1 || root->val == o2)
return root->val;
//左子树寻找公共祖先
int left = lowestCommonAncestor(root->left, o1, o2);
//右子树寻找公共祖先
int right = lowestCommonAncestor(root->right, o1, o2);
//左子树为没找到，则在右子树中
if(left == -1)
return right;
//右子树没找到，则在左子树中
if(right == -1)
return left;
//否则是当前节点
return root->val;
}
};
Python实现代码
class Solution:
def lowestCommonAncestor(self , root: TreeNode, o1: int, o2: int) -> int:
# 该子树没找到，返回-1
if not root:
return -1
# 该节点是其中某一个节点
if root.val == o1 or root.val == o2:
return root.val
# 左子树寻找公共祖先
left = self.lowestCommonAncestor(root.left, o1, o2)
# 右子树寻找公共祖先
right = self.lowestCommonAncestor(root.right, o1, o2)
# 左子树为没找到，则在右子树中
if left == -1:
return right
# 右子树没找到，则在左子树中
if right == -1:
return left
# 否则是当前节点
return root.val
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为节点数，递归遍历二叉树每一个节点
- 空间复杂度： O ( n ) O(n) O(n)，最坏情况二叉树化为链表，递归栈深度为 n n n
题目的主要信息：
- 找出所有和为S的连续正数序列，序列至少包括两个数
- 序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：枚举（前置方法）
思路：
我们可以从数字1开始枚举连续的数字，将其累加判断其是否等于目标，如果小于目标数则继续往后累加，如果大于目标数说明会超过，跳出，继续枚举下一个数字开始的情况（比如2，比如3），这样每次都取连续的序列，只有刚好累加和等于目标数才可以记录从开始到结束这一串数字，代表是一个符合的序列。
//枚举左区间
for(int i = 1; i <= up; i++){
//从左区间往后依次连续累加
for(int j = i; ;j++){
...
而因为序列至少两个数，每次枚举区间的起始数字最多到目标数的一半向下取整即可，因为两个大于目标数一半的数相加一定大于目标数。
具体做法：
- step 1：从1到目标值一半向下取整作为枚举的左区间，即每次序列开始的位置。
- step 2：从每个区间首部开始，依次往后累加，如果大于目标值说明这一串序列找不到，换下一个起点。
- step 3：如果加到某个数字刚好等于目标值，则记录从区间首到区间尾的数字。
Java实现代码：
import java.util.*;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
int sum1 = 0;
//因为序列至少两个数，因此枚举最多到该数字的一半向下取整
int up = (sum - 1) / 2;
//枚举左区间
for(int i = 1; i <= up; i++){
//从左区间往后依次连续累加
for(int j = i; ;j++){
sum1 += j;
//大于目标和则跳出该左区间
if(sum1 > sum){
sum1 = 0;
break;
//等于则找到
}else if(sum1 == sum){
sum1 = 0;
ArrayList<Integer> temp = new ArrayList<Integer>();
//记录线序的数字
for(int k = i; k <= j; k++)
temp.add(k);
res.add(temp);
break;
}
}
}
return res;
}
}
C++实现代码：
class Solution {
public:
vector<vector<int> > FindContinuousSequence(int sum) {
vector<vector<int> > res;
vector<int> temp;
int sum1 = 0;
//因为序列至少两个数，因此枚举最多到该数字的一半向下取整
int up = (sum - 1) / 2;
//枚举左区间
for(int i = 1; i <= up; i++){
//从左区间往后依次连续累加
for(int j = i; ;j++){
sum1 += j;
//大于目标和则跳出该左区间
if(sum1 > sum){
sum1 = 0;
break;
//等于则找到
}else if(sum1 == sum){
sum1 = 0;
temp.clear();
//记录线序的数字
for(int k = i; k <= j; k++)
temp.push_back(k);
res.push_back(temp);
break;
}
}
}
return res;
}
};
Python实现代码：
class Solution:
def FindContinuousSequence(self , sum: int) -> List[List[int]]:
res = []
sum1 = 0
#因为序列至少两个数，因此枚举最多到该数字的一半向下取整
up = (sum - 1) // 2
#枚举左区间
for i in range(1, up + 1):
#从左区间往后依次连续累加
j = i
while True:
sum1 += j
#大于目标和则跳出该左区间
if sum1 > sum:
sum1 = 0
break
#等于则找到
elif sum1 == sum:
sum1 = 0
temp = []
#记录线序的数字
for k in range(i, j + 1):
temp.append(k)
res.append(temp)
break
j += 1
return res
复杂度分析：
- 时间复杂度： O ( n n ) O(n\sqrt n) O(nn)，其中 n n n为目标数字sum，外层枚举最多 ⌊ n / 2 ⌋ \lfloor n/2 \rfloor ⌊n/2⌋次，内层判断最多不会超过 O ( n ) O(\sqrt n) O(n)，因为如果从1累加到 n \sqrt n n会大于 n n n，而从1累加到 n − 1 \sqrt n -1 n−1会小于 n n n，因此最坏情况下累加 n \sqrt n n次
- 空间复杂度： O ( n ) O(\sqrt n) O(n)，其中res属于返回答案必要空间，额外空间只有temp数组，最坏情况长度为 n \sqrt n n
方法二：滑动窗口（推荐使用）
知识点：滑动窗口
滑动窗口是指在数组、字符串、链表等线性结构上的一段，类似一个窗口，而这个窗口可以依次在上述线性结构上从头到尾滑动，且窗口的首尾可以收缩。我们在处理滑动窗口的时候，常用双指针来解决，左指针维护窗口左界，右指针维护窗口右界，二者同方向不同速率移动维持窗口。
思路：
从某一个数字开始的连续序列和等于目标数如果有，只能有一个，于是我们可以用这个性质来使区间滑动。
两个指针l、r指向区间首和区间尾，公式 ( l + r ) ∗ ( r − l + 1 ) / 2 (l + r) * (r - l + 1) / 2 (l+r)∗(r−l+1)/2计算区间内部的序列和，如果这个和刚好等于目标数，说明以该区间首开始的序列找到了，记录下区间内的序列，同时以左边开始的起点就没有序列了，于是左区间收缩；如果区间和大于目标数，说明该区间过长需要收缩，只能收缩左边；如果该区间和小于目标数，说明该区间过短需要扩大，只能向右扩大，移动区间尾。
具体做法：
- step 1：从区间 [ 1 , 2 ] [1,2] [1,2]开始找连续子序列。
- step 2：每次用公式计算区间内的和，若是等于目标数，则记录下该区间的所有数字，为一种序列，同时左区间指针向右。
- step 3：若是区间内的序列和小于目标数，只能右区间扩展，若是区间内的序列和大于目标数，只能左区间收缩。
图示：
Java实现代码：
import java.util.*;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
//从1到2的区间开始
for(int l = 1, r = 2; l < r;){
//计算区间内的连续和
int sum1 = (l + r) * (r - l + 1) / 2;
//如果区间内和等于目标数
if(sum1 == sum){
ArrayList<Integer> temp = new ArrayList<Integer>();
//记录区间序列
for(int i = l; i <= r; i++)
temp.add(i);
res.add(temp);
//左区间向右
l++;
//如果区间内的序列和小于目标数，右区间扩展
}else if(sum1 < sum)
r++;
//如果区间内的序列和大于目标数，左区间收缩
else
l++;
}
return res;
}
}
C++实现代码：
class Solution {
public:
vector<vector<int> > FindContinuousSequence(int sum) {
vector<vector<int> > res;
vector<int> temp;
//从1到2的区间开始
for(int l = 1, r = 2; l < r;){
//计算区间内的连续和
int sum1 = (l + r) * (r - l + 1) / 2;
//如果区间内和等于目标数
if(sum1 == sum){
temp.clear();
//记录区间序列
for(int i = l; i <= r; i++)
temp.push_back(i);
res.push_back(temp);
//左区间向右
l++;
//如果区间内的序列和小于目标数，右区间扩展
}else if(sum1 < sum)
r++;
//如果区间内的序列和大于目标数，左区间收缩
else
l++;
}
return res;
}
};
Python实现代码：
class Solution:
def FindContinuousSequence(self , sum: int) -> List[List[int]]:
res = []
#从1到2的区间开始
l = 1
r = 2
while l < r:
#计算区间内的连续和
sum1 = (l + r) * (r - l + 1) / 2
#如果区间内和等于目标数
if sum1 == sum:
temp = []
#记录区间序列
for i in range(l, r + 1):
temp.append(i)
res.append(temp)
#左区间向右
l += 1
#如果区间内的序列和小于目标数，右区间扩展
elif sum1 < sum:
r += 1
#如果区间内的序列和大于目标数，左区间收缩
else:
l += 1
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，区间移动次数最多 ⌊ n / 2 ⌋ \lfloor n/2 \rfloor ⌊n/2⌋次
- 空间复杂度： O ( n ) O(\sqrt n) O(n)，其中res属于返回答案必要空间，额外空间只有temp数组，最坏情况长度为 n \sqrt n n
题目的主要信息：
- 升序数组中找到和为S的两个数字
- 若有多组，返回任意一组
- 无法找到则返回空数组
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：哈希表（推荐使用）
知识点：哈希表
哈希表是一种根据关键码（key）直接访问值（value）的一种数据结构。而这种直接访问意味着只要知道key就能在 O ( 1 ) O(1) O(1)时间内得到value，因此哈希表常用来统计频率、快速检验某个元素是否出现过等。
思路：
我们能想到最直观的解法，可能就是两层遍历，将数组所有的二元组合枚举一遍，看看是否是和为目标值，但是这样太费时间了，既然加法这么复杂，我们是不是可以尝试一下减法：对于数组中出现的一个数a，如果目标值减去a的值已经出现过了，那这不就是我们要找的一对元组吗？这种时候，快速找到已经出现过的某个值，可以考虑使用哈希表快速检验某个元素是否出现过这一功能。
具体做法：
- step 1：构建一个哈希表，其中key值为遍历数组过程中出现过的值，value值为其相应的下标，因为我们最终要返回的是下标。
- step 2：遍历数组每个元素，如果目标值减去该元素的结果在哈希表中存在，说明我们先前遍历的时候它出现过，根据记录的下标，就可以得到结果。
- step 3：如果相减后的结果没有在哈希表中，说明先前遍历的元素中没有它对应的另一个值，那我们将它加入哈希表，等待后续它匹配的那个值出现即可。
Java实现代码：
import java.util.*;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
ArrayList<Integer> res = new ArrayList<Integer>();
//创建哈希表,两元组分别表示值、下标
HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>();
//在哈希表中查找target-numbers[i]
for(int i = 0; i < array.length; i++){
int temp = sum - array[i];
//若是没找到，将此信息计入哈希表
if(!mp.containsKey(temp)){
mp.put(array[i], i);
}
else{
//取出数字添加
res.add(temp);
res.add(array[i]);
break;
}
}
return res;
}
}
C++实现代码：
class Solution {
public:
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
vector<int> res;
//创建哈希表,两元组分别表示值、下标
unordered_map<int, int> mp;
//在哈希表中查找sum-array[i]
for(int i = 0; i < array.size(); i++){
int temp = sum - array[i];
//若是没找到，将此信息计入哈希表
if(mp.find(temp) == mp.end()){
mp[array[i]] = i;
}
else{
//取出数字添加
res.push_back(temp);
res.push_back(array[i]);
break;
}
}
return res;
}
};
Python实现代码：
class Solution:
def FindNumbersWithSum(self , array: List[int], sum: int) -> List[int]:
res = []
#创建哈希表,两元组分别表示值、下标
mp = dict()
#在哈希表中查找sum-array[i]
for i in range(len(array)):
temp = sum - array[i]
#若是没找到，将此信息计入哈希表
if temp not in mp:
mp[array[i]] = i
else:
#取出数字添加
res.append(temp)
res.append(array[i])
break
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为数组长度，遍历一次数组
- 空间复杂度： O ( n ) O(n) O(n)，哈希表最大空间为 n n n
方法二：双指针（扩展思路）
知识点：双指针
双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个指针（特殊情况甚至可以多个），两个指针或是同方向访问两个链表、或是同方向访问一个链表（快慢指针）、或是相反方向扫描（对撞指针），从而达到我们需要的目的。
思路：
这道题目还有一个条件是数组是升序序列，在方法一中没有用到。这个条件有什么用？既然数组是有序的，那我们肯定知道和找到一定程度就不找了，我们为什么要从最小的两个数开始相加呢？我们可以用二分法的思路，从中间开始找。
使用双指针指向数组第一个元素和最后一个元素，然后双指针对撞移动，如果两个指针下的和正好等于目标值sum，那我们肯定找到了，如果和小于sum，说明我们需要找到更大的，那只能增加左边的元素，如果和大于sum，说明我们需要找更小的，只能减小右边的元素。
具体做法：
- step 1：准备左右双指针分别指向数组首尾元素。
- step 2：如果两个指针下的和正好等于目标值sum，则找到了所求的两个元素。
- step 3：如果两个指针下的和大于目标值sum，右指针左移；如果两个指针下的和小于目标值sum，左指针右移。
- step 4：当两指针对撞时，还没有找到，就是数组没有。
图示：
Java实现代码：
import java.util.*;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
ArrayList<Integer> res = new ArrayList<Integer>();
//左右双指针
int left = 0, right = array.length - 1;
//对撞双指针
while(left < right){
//相加等于sum，找到目标
if(array[left] + array[right] == sum){
res.add(array[left]);
res.add(array[right]);
break;
//和太大，缩小右边
}else if(array[left] + array[right] > sum)
right--;
//和太小，扩大左边
else
left++;
}
return res;
}
}
C++实现代码：
class Solution {
public:
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
vector<int> res;
//左右双指针
int left = 0, right = array.size() - 1;
//对撞双指针
while(left < right){
//相加等于sum，找到目标
if(array[left] + array[right] == sum){
res.push_back(array[left]);
res.push_back(array[right]);
break;
//和太大，缩小右边
}else if(array[left] + array[right] > sum)
right--;
//和太小，扩大左边
else
left++;
}
return res;
}
};
Python实现代码：
class Solution:
def FindNumbersWithSum(self , array: List[int], sum: int) -> List[int]:
res = []
#左右双指针
left = 0
right = len(array) - 1
#对撞双指针
while left < right:
#相加等于sum，找到目标
if array[left] + array[right] == sum:
res.append(array[left])
res.append(array[right])
break
#和太大，缩小右边
elif array[left] + array[right] > sum:
right -= 1
#和太小，扩大左边
else:
left += 1
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为数组长度，左右指针共同遍历一次数组
- 空间复杂度： O ( 1 ) O(1) O(1)，常数个变量，无额外辅助空间
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
