给定一颗二叉树,以及其中的两个node(地址均非空),要求给出这两个node的一个公共父节点,使得这个父节点与两个节点的路径之和最小。

本文介绍了一种算法,用于寻找二叉树中两个指定节点的最近公共祖先,使从该祖先到两个节点的路径之和最小。提供两种实现方法及其时间复杂度分析。
给定一颗二叉树,以及其中的两个node(地址均非空),要求给出这两个node的一个公共父节点,使得这个父节点与两个节点的路径之和最小。描述你程序的最坏时间复杂度,并实现具体函数,函数输入输出请参考如下的函数原型:
C++函数原型:
1
2
3
4
5
6
7
strucy TreeNode{
     TreeNode* left;   //指向左子树
     TreeNode* right;   //指向右子树
     TreeNode* father;   //指向父亲节点
};
TreeNode* LowestCommonAncestor(TreeNode* first,TreeNode* second){
}

由于有父节点指针,这道题目的难度一下子就降低了许多。

思路一:我们首先找到两个节点的高度差,然后从较靠近根结点的一层开始向上找,若父节点为同一节点则该节点为解。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
int getHeight(TreeNode *node) {
    int height = 0;
    while (node) {
        height++;
        node = node->parent;
    }
    return height;
}
 
TreeNode* LowestCommonAncestor(TreeNode* first,TreeNode* second) {
    int height1 = getHeight(first), height2 = getHeight(second), diff = height1 - height2;
    if (diff < 0) {
        diff = -diff;
        while(diff--) {
             second = second->parent;
        }
    else {
        while(diff--) {
            first = first->parent;
        }
    }
    while (first != second) {
        first = first->parent;
        second = second->parent;
    }
    return first;
}

思路二:若允许浪费空间,那么可以用两个Stack来存储从first和second到根结点的各个节点,然后出栈时比较地址是否一致,最后一个地址一致的节点为解。

两种方法最坏时间复杂度均为O(n)。


二叉树中查找两个指定节点公共祖先,有递归和迭代两种常见的实现方法: ### 递归方法 递归方法的基本思路是从左右子树中分别查找,再依据查找的结果进行判断:如果左右子树有一个子树查找到,则返回对应的子树;如果都查找到则返回当前的节点(当前节点就是公共祖先);如果都没有查找到,则返回 `Null`。以下是具体的代码实现: ```cpp #include <iostream> // 定义二叉树节点结构 struct BinaryTreeNode { int m_nValue; BinaryTreeNode* m_pLeft; BinaryTreeNode* m_pRight; BinaryTreeNode(int value) : m_nValue(value), m_pLeft(nullptr), m_pRight(nullptr) {} }; // 递归计算根节点 node1、node2 的关系 bool LCA(BinaryTreeNode* root, BinaryTreeNode* node1, BinaryTreeNode* node2, BinaryTreeNode*& result, BinaryTreeNode* parent) { if (!root) { return false; } bool flag1 = LCA(root->m_pLeft, node1, node2, result, root); bool flag2 = LCA(root->m_pRight, node1, node2, result, root); // 在节点两个子树上 if (flag1 && flag2) { // 只有确定在两棵子树上时,根节点为共同父节点 result = root; return true; } // 其中的一个节点是根节点 if (root->m_nValue == node1->m_nValue || root->m_nValue == node2->m_nValue) { if (flag1 || flag2) { result = parent; } return true; } return flag1 || flag2; } // 函数入口 BinaryTreeNode* RecurLCA(BinaryTreeNode* root, BinaryTreeNode* node1, BinaryTreeNode* node2) { BinaryTreeNode* result = nullptr; LCA(root, node1, node2, result, nullptr); return result; } ``` ### 迭代方法 迭代方法使用队列进行层序遍历,记录每个节点父节点,然后从其中一个节点开始向上遍历其祖先节点,直到找到另一个节点的祖先节点。以下是具体的代码实现: ```java import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; import java.util.Map; import java.util.Queue; import java.util.Set; // 定义二叉树节点类 class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } public class Solution { public int lowestCommonAncestor(TreeNode root, int o1, int o2) { // 记录遍历到的每个节点父节点 Map<Integer, Integer> parent = new HashMap<>(); Queue<TreeNode> queue = new LinkedList<>(); parent.put(root.val, Integer.MIN_VALUE); // 根节点没有父节点,给它默认一个值 queue.add(root); // 直到两个节点都找到为止 while (!parent.containsKey(o1) || !parent.containsKey(o2)) { // 队列是一边进一边,这里 poll 方法是队 TreeNode node = queue.poll(); if (node.left != null) { // 左子节点不为,记录下它的父节点 parent.put(node.left.val, node.val); // 左子节点不为,把它加入到队列中 queue.add(node.left); } // 右节点同上 if (node.right != null) { parent.put(node.right.val, node.val); queue.add(node.right); } } Set<Integer> ancestors = new HashSet<>(); // 记录下 o1 和它的祖先节点,从 o1 节点开始一直到根节点 while (parent.containsKey(o1)) { ancestors.add(o1); o1 = parent.get(o1); } // 查看 o1 和它的祖先节点是否包含 o2 节点,如果不包含再看是否包含 o2 的父节点…… while (!ancestors.contains(o2)) { o2 = parent.get(o2); } return o2; } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值