[已解决]二叉树，设计算法求解公共祖先

白痴爱面包

设计算法以求解编号为i和j的两个结点的最近的公共祖先结点的编号。

最佳答案

月排行榜 / 总排行榜

isdkz

2023-4-8 20:22:39

白痴爱面包 发表于 2023-4-8 20:19
有其他方法吗，示例用c或c++

以下是使用C++编写的另一种求解二叉树中两个结点最近公共祖先的方法。

这种方法基于向上追踪祖先结点的思路。

1. #include <iostream>
   
2. #include <algorithm>
   
3. #include <vector>
   
4. 
   
5. using namespace std;
   
6. 
   
7. // 计算结点的深度
   
8. int getNodeDepth(int node) {
   
9.     int depth = 0;
   
10.     while (node > 1) {
    
11.         node = node / 2;
    
12.         depth++;
    
13.     }
    
14.     return depth;
    
15. }
    
16. 
    
17. // 查找公共祖先
    
18. int findLowestCommonAncestor(int i, int j) {
    
19.     // 计算两个结点的深度
    
20.     int depth_i = getNodeDepth(i);
    
21.     int depth_j = getNodeDepth(j);
    
22. 
    
23.     // 调整深度使两个结点在同一层
    
24.     while (depth_i > depth_j) {
    
25.         i = i / 2;
    
26.         depth_i--;
    
27.     }
    
28. 
    
29.     while (depth_j > depth_i) {
    
30.         j = j / 2;
    
31.         depth_j--;
    
32.     }
    
33. 
    
34.     // 向上追踪公共祖先
    
35.     while (i != j) {
    
36.         i = i / 2;
    
37.         j = j / 2;
    
38.     }
    
39. 
    
40.     return i;
    
41. }
    
42. 
    
43. int main() {
    
44.     int i = 9;
    
45.     int j = 13;
    
46.     cout << findLowestCommonAncestor(i, j) << endl;  // 输出：2
    
47. 
    
48.     return 0;
    
49. }
    

复制代码

这种方法首先计算两个结点的深度，然后调整深度使它们在同一层。

接下来，同时向上追踪两个结点的祖先，直到找到它们的公共祖先为止。

跳转到最佳答案楼层

isdkz

在二叉树中，我们可以通过结点编号的二进制表示来追踪它们的祖先。对于给定的结点i和j，我们可以使用以下算法求解它们的最近公共祖先结点的编号：

• 将结点i和j的编号分别转换为二进制表示，例如：i = 1001（二进制），j = 1101（二进制）。
  
• 在二进制表示中，从最高位开始，找到第一个不同的二进制位，例如：第一个不同的二进制位在本例中是第二位。
  
• 截取从最高位开始到第一个不同二进制位之前的部分，然后将其转换回十进制，得到的数就是最近公共祖先结点的编号，例如：公共祖先结点的二进制表示为10，转换为十进制后得到2。
  

下面是用Python实现的该算法：

1. def find_lowest_common_ancestor(i, j):
   
2.     # 转换为二进制表示并去掉'0b'前缀
   
3.     i_bin = bin(i)[2:]
   
4.     j_bin = bin(j)[2:]
   
5. 
   
6.     # 获取最短长度
   
7.     min_len = min(len(i_bin), len(j_bin))
   
8. 
   
9.     # 寻找第一个不同的二进制位
   
10.     diff_index = -1
    
11.     for k in range(min_len):
    
12.         if i_bin[k] != j_bin[k]:
    
13.             diff_index = k
    
14.             break
    
15. 
    
16.     # 如果没有找到不同的二进制位，则取最短长度作为截止点
    
17.     if diff_index == -1:
    
18.         diff_index = min_len
    
19. 
    
20.     # 获取公共祖先的二进制表示，并转换为十进制
    
21.     common_ancestor_bin = i_bin[:diff_index]
    
22.     common_ancestor = int(common_ancestor_bin, 2)
    
23. 
    
24.     return common_ancestor
    
25. 
    
26. # 测试
    
27. i = 9
    
28. j = 13
    
29. print(find_lowest_common_ancestor(i, j))  # 输出：2

复制代码

以上算法可以高效地求解二叉树中任意两个结点的最近公共祖先结点的编号。

白痴爱面包

isdkz 发表于 2023-4-8 19:49
在二叉树中，我们可以通过结点编号的二进制表示来追踪它们的祖先。对于给定的结点i和j，我们可以使用以下算 ...

有其他方法吗，示例用c或c++

isdkz

白痴爱面包 发表于 2023-4-8 20:19
有其他方法吗，示例用c或c++

以下是使用C++编写的另一种求解二叉树中两个结点最近公共祖先的方法。

这种方法基于向上追踪祖先结点的思路。

1. #include <iostream>
   
2. #include <algorithm>
   
3. #include <vector>
   
4. 
   
5. using namespace std;
   
6. 
   
7. // 计算结点的深度
   
8. int getNodeDepth(int node) {
   
9.     int depth = 0;
   
10.     while (node > 1) {
    
11.         node = node / 2;
    
12.         depth++;
    
13.     }
    
14.     return depth;
    
15. }
    
16. 
    
17. // 查找公共祖先
    
18. int findLowestCommonAncestor(int i, int j) {
    
19.     // 计算两个结点的深度
    
20.     int depth_i = getNodeDepth(i);
    
21.     int depth_j = getNodeDepth(j);
    
22. 
    
23.     // 调整深度使两个结点在同一层
    
24.     while (depth_i > depth_j) {
    
25.         i = i / 2;
    
26.         depth_i--;
    
27.     }
    
28. 
    
29.     while (depth_j > depth_i) {
    
30.         j = j / 2;
    
31.         depth_j--;
    
32.     }
    
33. 
    
34.     // 向上追踪公共祖先
    
35.     while (i != j) {
    
36.         i = i / 2;
    
37.         j = j / 2;
    
38.     }
    
39. 
    
40.     return i;
    
41. }
    
42. 
    
43. int main() {
    
44.     int i = 9;
    
45.     int j = 13;
    
46.     cout << findLowestCommonAncestor(i, j) << endl;  // 输出：2
    
47. 
    
48.     return 0;
    
49. }
    

复制代码

这种方法首先计算两个结点的深度，然后调整深度使它们在同一层。

接下来，同时向上追踪两个结点的祖先，直到找到它们的公共祖先为止。