关闭

【剑指Offer学习】【面试题50:树中两个结点的最低公共祖先】

标签: offerjava面试算法
2578人阅读 评论(3) 收藏 举报
分类:

题目:求树中两个结点的最低公共祖先,此树不是二叉树,并且没有指向父节点的指针。


树的结点定义

private static class TreeNode {
    int val;

    List<TreeNode> children = new LinkedList<>();


    public TreeNode() {
    }

    public TreeNode(int val) {
        this.val = val;
    }

    @Override
    public String toString() {
        return  val + "";
    }
}

题目解析

 假设还是输入结点F和H .

这里写图片描述

  我们首先得到一条从根结点到树中某一结点的路径,这就要求在遍历的时候,有一个辅助内存来保存路径.比如我们用前序遍历的方法来得到从根结点到H 的路径的过程是这样的:( 1 )遍历到A,把A 存放到路径中去,路径中只有一个结点A; ( 2 )遍历到B,把B 存到路径中去,此时路径为A->B; ( 3 )遍历到D,把D 存放到路径中去,此,时路径为A->B->D; ( 4 ) :遍历到F,把F 存放到路径中去,此时路径为A->B->D->F;( 5) F 已经没有子结点了,因此这条路径不可能到这结点H. 把F 从路径中删除,变成A->B->D; ( 6 )遍历G. 和结点F 一样,这条路径也不能到达H. 边历完G 之后,路径仍然是A->B->D; ( 7 )由于D 的所有子结点都遍历过了,不可能到这结点H,因此D 不在从A 到H 的路径中,把D 从路径中删除,变成A->B; ( 8 )遥历E,把E 加入到路径中,此时路径变成A->B->E, ( 9 )遍历H,已经到达目标给点, A->B->E 就是从根结点开始到达H 必须经过的路径。
  同样,我们也可以得到从根结点开始到达F 必须经过的路径是A->B功。接着,我们求出这两个路径的最后公共结点,也就是B. B这个结点也是F 和H 的最低公共祖先.
  为了得到从根结点开始到输入的两个结点的两条路径,需要追历两次树,每边历一次的时间复杂度是O(n).得到的两条路径的长度在最差情况时是0(时,通常情况丁两条路径的长度是O(logn).

注意:可以在只遍历树一次就找到两个结点的路径,这部分留给读者自己去完成。

代码实现

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Test50 {
    /**
     * 树的结点定义
     */
    private static class TreeNode {
        int val;

        List<TreeNode> children = new LinkedList<>();


        public TreeNode() {
        }

        public TreeNode(int val) {
            this.val = val;
        }

        @Override
        public String toString() {
            return val + "";
        }
    }

    /**
     * 找结点的路径
     *
     * @param root   根结点
     * @param target 目标结点
     * @param path   从根结点到目标结点的路径
     */
    public static void getNodePath(TreeNode root, TreeNode target, List<TreeNode> path) {
        if (root == null) {
            return;
        }

        // 添加当前结点
        path.add(root);

        List<TreeNode> children = root.children;
        // 处理子结点
        for (TreeNode node : children) {

            if (node == target) {
                path.add(node);
                return;
            } else {
                getNodePath(node, target, path);
            }
        }

        // 现场还原
        path.remove(path.size() - 1);
    }

    /**
     * 找两个路径中的最后一个共同的结点
     *
     * @param p1 路径1
     * @param p2 路径2
     * @return 共同的结点,没有返回null
     */
    public static TreeNode getLastCommonNode(List<TreeNode> p1, List<TreeNode> p2) {
        Iterator<TreeNode> ite1 = p1.iterator();
        Iterator<TreeNode> ite2 = p2.iterator();
        TreeNode last = null;

        while (ite1.hasNext() && ite2.hasNext()) {
            TreeNode tmp = ite1.next();
            if (tmp == ite2.next()) {
                last = tmp;
            }
        }

        return last;

    }

    /**
     * 找树中两个结点的最低公共祖先
     * @param root 树的根结点
     * @param p1 结点1
     * @param p2 结点2
     * @return 公共结点,没有返回null
     */
    public static TreeNode getLastCommonParent(TreeNode root, TreeNode p1, TreeNode p2) {
        if (root == null || p1 == null || p2 == null) {
            return null;
        }
        List<TreeNode> path1 = new LinkedList<>();
        getNodePath(root, p1, path1);
        List<TreeNode> path2 = new LinkedList<>();
        getNodePath(root, p2, path2);

        return getLastCommonNode(path1, path2);
    }

    public static void main(String[] args) {
        test01();
        System.out.println("==========");
        test02();
        System.out.println("==========");
        test03();
    }


    // 形状普通的树
    //             1
    //           /   \
    //         2      3
    //        /         \
    //      4            5
    //     / \        /  |  \
    //    6   7      8   9  10
    public static void test01() {
        TreeNode n1 = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(3);
        TreeNode n4 = new TreeNode(4);
        TreeNode n5 = new TreeNode(5);
        TreeNode n6 = new TreeNode(6);
        TreeNode n7 = new TreeNode(7);
        TreeNode n8 = new TreeNode(8);
        TreeNode n9 = new TreeNode(9);
        TreeNode n10 = new TreeNode(10);

        n1.children.add(n2);
        n1.children.add(n3);

        n2.children.add(n4);

        n4.children.add(n6);
        n4.children.add(n7);

        n3.children.add(n5);

        n5.children.add(n8);
        n5.children.add(n9);
        n5.children.add(n10);

        System.out.println(getLastCommonParent(n1, n6, n8));
    }

    // 树退化成一个链表
    //               1
    //              /
    //             2
    //            /
    //           3
    //          /
    //         4
    //        /
    //       5
    private static void test02() {
        TreeNode n1 = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(3);
        TreeNode n4 = new TreeNode(4);
        TreeNode n5 = new TreeNode(5);

        n1.children.add(n2);
        n2.children.add(n3);
        n3.children.add(n4);
        n4.children.add(n5);

        System.out.println(getLastCommonParent(n1, n4, n5));
    }

    // 树退化成一个链表,一个结点不在树中
    //               1
    //              /
    //             2
    //            /
    //           3
    //          /
    //         4
    //        /
    //       5
    private static void test03() {
        TreeNode n1 = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(3);
        TreeNode n4 = new TreeNode(4);
        TreeNode n5 = new TreeNode(5);
        TreeNode n6 = new TreeNode(6);

        n1.children.add(n2);
        n2.children.add(n3);
        n3.children.add(n4);
        n4.children.add(n5);

        System.out.println(getLastCommonParent(n1, n5, n6));
    }
}

运行结果

这里写图片描述

2
0
查看评论

剑指offer 面试题50—树中两个节点的最低公共祖先

#include #include #include using namespace std; typedef struct TreeNode { int data; struct TreeNode *lchild; struct TreeNode *r...
  • wtyvhreal
  • wtyvhreal
  • 2015-05-07 19:23
  • 1880

剑指Offer之 - 树中两个结点的最低公共祖先

题目: 求树中两个节点的最低公共祖先。 思路一: ——如果是二叉树,而且是二叉搜索树,那么是可以找到公共节点的。 二叉搜索树都是排序过的,位于左子树的节点都比父节点小,而位于右子树上面的节点都比父节点大。 如果当前节点的值比两个结点 的值都大,那么最低的共同的父节点一定是在当前节点的...
  • u012243115
  • u012243115
  • 2015-04-29 16:07
  • 547

《剑指Offer》学习笔记--面试题50:树中两个结点的最低公共祖先

题目:求树中两个结点的最低公共祖先,此树不是二叉树,并且没有指向父节点的指针。 bool GetNodePath(TreeNode* pRoot, TreeNode* pNode, list&path) { if(pRoot == pNode) return true; path....
  • zhouwei1221q
  • zhouwei1221q
  • 2015-05-15 14:35
  • 244

《剑指offer》:[50]树中两个结点的最低公共祖先结点

题目:树中两个结点的最低公共祖先 该题目根据条件的不同,所使用的方案也不同。 条件一:是二叉搜索树。      方案:这种情况相对来说是最简单的,如果是二叉搜索树,则树里的数据特点比较明显。左边的比根结点小,右边的比根结点大。所以其最低的公共结点就是第一个在这两个输入节...
  • gogoky
  • gogoky
  • 2016-06-25 15:32
  • 910

剑指Offer(第二版)面试案例:树中两个节点的最低公共祖先节点

树中两个节点的最低公共祖先节点
  • qq_25827845
  • qq_25827845
  • 2017-07-06 22:03
  • 1529

《剑指offer》树中两个结点的最低公共祖先

说实话,和这题很有缘分。首先,这个题目给我印象很深,其次,今天在做蘑菇街实习生笔试时遇到了这个题目,所以感觉应该写博客,把这个题目记录下来。笔试时遇到的题目是:给定二叉树中的两个结点,寻找最低公共节点。如果树的节点有指向父节点的指针这是一种情况,是比较简单的情况。 这种情况就相当于求两条链表的公共...
  • u010357247
  • u010357247
  • 2015-04-11 00:27
  • 499

面试题50:二叉树中两个节点的最低公共祖先

#include #include #include using namespace std; typedef struct BtNode { int value; struct BtNode *lchild; struct BtNode *rchild; }BtNode, *Bi...
  • damotiansheng
  • damotiansheng
  • 2016-05-31 20:24
  • 644

求树中两个节点的最低公共祖先

情形1:树是搜索二叉树 思路:从树的根节点开始遍历,如果根节点的值大于其中一个节点,小于另外一个节点,则根节点就是最低公共祖先。否则如果根节点的值小于两个节点的值,则递归求根节点的右子树,如果大于两个节点的值则递归求根的左子树。如果根节点正好是其中的一个节点,那么说明这两个节点在一条路径上,所...
  • jingshuigg
  • jingshuigg
  • 2014-06-15 22:31
  • 2246

树中两个节点的最低公共祖先(Java实现)

本题为剑指offer面试题50 在牛客网没有找到类似的题目,所以笔者自己建了三棵树进行测试 如有问题欢迎指正。 题目:求树中两个结点的最低公共祖先 分析:其实这是一组题目,考官没有说清楚树的结构,那么做法就不尽相同。 比如,如果是二叉搜索树的话,我们只需从根结点判断...
  • zjkC050818
  • zjkC050818
  • 2017-05-22 09:59
  • 1259

面试题50. 树中两个结点的最低公共祖先结点

面试题50. 树中两个结点的最低公共祖先结点题目描述:给出一个二叉树,找到两个结点的最低公共祖先。比如下面的二叉树中,5和1的最低公共祖先就是3; 4和6的最低公共祖先就是5。 _______3______ / \ ___5__ ...
  • u010429424
  • u010429424
  • 2017-09-13 16:29
  • 495
    个人资料
    • 访问:1071919次
    • 积分:16624
    • 等级:
    • 排名:第734名
    • 原创:528篇
    • 转载:18篇
    • 译文:13篇
    • 评论:210条
    博客专栏
    最新评论