【IT笔试面试题整理】寻找二叉树两节点的最近的公共祖先

【试题描述】

求二叉树中任意两个节点的最近公共祖先也称为LCA问题（Lowest Common Ancestor）。

二叉查找树

如果该二叉树是二叉查找树，那么求解LCA十分简单。

基本思想为：从树根开始，该节点的值为t，如果t大于t1和t2，说明t1和t2都位于t的左侧，所以它们的共同祖先必定在t的左子树中，从t.left开始搜索；如果t小于t1和t2，说明t1和t2都位于t的右侧，那么从t.right开始搜索；如果t1<t< t2，说明t1和t2位于t的两侧，那么该节点t为公共祖先。

如果t1是t2的祖先，那么应该返回t1的父节点；同理，如果t2是t1的祖先，应该返回t2的父节点。

【参考代码】

public int query(Node t1, Node t2, Node t) {
    int left = t1.value;
    int right = t2.value;
    Node parent = null;
        
    if (left > right) {
        int temp = left;
        left = right;
        right = temp;
    }
        
    while (true) {
        if (t.value < left) {
            parent = t;
            t = t.right;
        } else if (t.value > right) {
            parent = t;
            t = t.left;
        } else if (t.value == left || t.value == right) {
            return parent.value;
        } else {
            return t.value;
        }
    }
}

普通二叉树

算法思想：如果一个节点的左子树包含p，q中的一个节点，右子树包含另一个，则这个节点就是p，q的最近公共祖先。

【参考代码】

解法一：

public static Node findNCA(Node root, Node p, Node q)
    {
        if (isintree(root.left, p) && isintree(root.left, q))
            return findNCA(root.left, p, q);
        if (isintree(root.right, p) && isintree(root.right, q))
            return findNCA(root.right, p, q);
        return root;
    }

    public static boolean isintree(Node root, Node node)
    {
        if (root == null)
            return false;
        if (root == node)
            return true;
        return isintree(root.left, node) || isintree(root.right, node);
    }

解法二：

static int TWO_NODES_FOUND = 2;
    static int ONE_NODES_FOUND = 1;
    static int NO_NODES_FOUND = 0;

    public static int covers(Node root, Node p, Node q)
    {
        int ret = NO_NODES_FOUND;
        if (root == null)
            return ret;
        if (root == p || root == q)
            ret += 1;
        ret += covers(root.left, p, q);
        if (ret == TWO_NODES_FOUND)
            return ret;
        return ret + covers(root.right, p, q);
    }

    private static Node findNCA(Node root, Node p, Node q)
    {
        if (q == p && (root.left == q || root.right == q))
            return root;
        int nodesFromLeft = covers(root.left, p, q);
        if (nodesFromLeft == TWO_NODES_FOUND)
        {
            if (root.left == p || root.left == q)
                return root.left;
            else
                return findNCA(root.left, p, q);
        } else if (nodesFromLeft == ONE_NODES_FOUND)
        {
            if (root == p)
                return p;
            else if (root == q)
                return q;
        }

        int nodesFromRight = covers(root.right, p, q);
        if (nodesFromRight == TWO_NODES_FOUND)
        {
            if (root.right == p || root.right == q)
                return root.right;
            else
                return findNCA(root.right, p, q);
        } else if (nodesFromRight == ONE_NODES_FOUND)
        {
            if (root == p)
                return p;
            else if (root == q)
                return q;
        }

        if (nodesFromLeft == ONE_NODES_FOUND
                && nodesFromLeft == ONE_NODES_FOUND)
            return root;
        else
            return null;
    }

解法三：
网上版本：

public static int FindNCA(Node root, Node a, Node b, Node out)
    {
        if (root == null)
            return 0;
        if (root == a || root == b)
            return 1;

        int iLeft = FindNCA(root.left, a, b, out);
        if (iLeft == 2)
            return 2;

        int iRight = FindNCA(root.right, a, b, out);
        if (iRight == 2)
            return 2;

        if (iLeft + iRight == 2)
            out = root;

        return iLeft + iRight;
    }

这个网上说输出时 当为2时才输出，但是为2时，不能判断如果其中一个是另一个的父亲节点情况。所以理论上应该改为当返回结果
大于0时，就可以输出结果。但是不太确定正确性，应该程序是正确的。

参考：

http://blog.csdn.net/w397090770/article/details/7615447