查找最近公共祖先(LCA)

一、問題

　　求有根樹的任意兩個節點的最近公共祖先（一般來說都是指二叉樹）。最近公共祖先簡稱LCA（Lowest Common Ancestor）。例如，如下圖一棵普通的二叉樹。

　　　　

　　結點3和結點4的最近公共祖先是結點2，即LCA（3，4）=2 。在此，需要注意到當兩個結點在同一棵子樹上的情況，如結點3和結點2的最近公共祖先為2，即 LCA（3，2）=2。同理：LCA（5，6）=4，LCA（6，10）=1。

　　明確了題意，咱們便來試着解決這個問題。直觀的做法，可能是針對是否為二叉查找樹分情況討論，這也是一般人最先想到的思路。除此之外，還有所謂的Tarjan算法、倍增算法、以及轉換為RMQ問題（求某段區間的極值）。后面這幾種算法相對高級，不那么直觀，但思路比較有啟發性，留作以后了解一下也有裨益。

二、思路

　　解法一：暴力解法，在有parent指針的情況下，對兩個節點依次向上回溯，直到兩個節點相同，那么這個節點就是最近公共祖先。時間復雜度為O(n²)

　　解法二：鏈表的交叉，在有parent指針的情況下，對兩個節點分別到根節點的路徑上的節點形成兩個鏈表，因為兩個鏈表很大可能不一樣長，然后我們可以對其中長的一個鏈表從開頭進行裁剪，形成兩個鏈表長度一樣，然后遍歷直到相等，雖說優化了一點，但本質上還是暴力破解。

　　解法三：借用數組和列表，在沒有parent指針的情況，我們只能從根節點往下遍歷，而不能進行往上回溯。所以可以借用數組或列表來保存數據，后面進行比對。和鏈表的交叉差不多。

　　解法四：不借用額外的數據結構，沒有parent指針。大概思路呢就是如果兩個節點分屬在根節點的兩邊，返回根節點，如果兩個節點同在左子樹或右子樹，遞歸求解。

　　解法五：這種解法現在不太懂，現在留作記錄以后觀看。其中解法四和解法五在代碼中體現。

三、代碼

import java.util.ArrayList;
import java.util.List;

public class LCA {
    public int getLCA(int a, int b) {
        TreeNode<Integer> root = of(10);

        TreeNode<Integer> lca = getLCA2(root, new TreeNode<Integer>(a), new TreeNode<Integer>(b));
        return lca == null ? -1 : lca.val;
    }

    //=====解法四===========
    // 看兩個節點是否在同一側  
    private TreeNode<Integer> getLCA(TreeNode<Integer> root, TreeNode<Integer> p, TreeNode<Integer> q) {
        if (root == null)
            return null;
        if (root.equals(p) || root.equals(q))
            return root;

        boolean is_p_on_left = cover(root.left, p);
        boolean is_q_on_right = cover(root.right, q);
        if (is_p_on_left == is_q_on_right) {// 在root的兩端
            return root;
        } else if (is_p_on_left) {// 在root的左端
            return getLCA(root.left, p, q);
        } else {
            return getLCA(root.right, p, q);
        }
    }

    // 解法五
    // 很難理解  遞歸定義不明確 第一次看到
    private TreeNode<Integer> getLCA2(TreeNode<Integer> root, TreeNode<Integer> p, TreeNode<Integer> q) {
        if (root == null)
            return null;
        if (root.equals(p) && root.equals(q))
            return root;

        // x是lca，或者是p（p在這一側），或者是q（q在這一側），或者是null（pq都不在這一側）
        TreeNode<Integer> x = getLCA2(root.left, p, q);
        if (x != null && !x.equals(p) && !x.equals(q)) {// 在左子樹找到了lca
            return x;
        }

        TreeNode<Integer> y = getLCA2(root.right, p, q);
        if (y != null && !y.equals(p) && !y.equals(q)) {// 在右子樹找到了lca
            return y;
        }

        // x：p,q,null y :q,p,null
        if (x != null && y != null) {// 一邊找着一個
            return root;
        } else if (root.equals(p) || root.equals(q)) {
            return root;
        } else {
            return x == null ? y : x;// 有一個不為null，則返回，都為null，返回null
        }
    }

    /**
     * 判斷x節點是否在n所代表的子樹中
     * 
     * @param n
     * @param x
     * @return
     */
    private boolean cover(TreeNode<Integer> n, TreeNode<Integer> x) {
        if (n == null)
            return false;
        if (n.equals(x))
            return true;
        return cover(n.left, x) || cover(n.right, x);
    }

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // 發現目標節點則通過返回值標記該子樹發現了某個目標結點
        if (root == null || root.equals(p.val) || root.equals(q))
            return root;
        // 查看左子樹中是否有目標結點，沒有為null
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        // 查看右子樹是否有目標節點，沒有為null
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        // 都不為空，說明左右子樹都有目標結點，則公共祖先就是本身
        if (left != null && right != null)
            return root;
        // 如果發現了目標節點，則繼續向上標記為該目標節點
        return left == null ? right : left;
    }

    static TreeNode<Integer> of(int n) {
        List<TreeNode<Integer>> list = new ArrayList<TreeNode<Integer>>();
        for (int i = 0; i < n; i++) {
            list.add(new TreeNode<Integer>(i + 1));
        }
        for (int i = 0; i < n; i++) {
            TreeNode<Integer> parent = list.get(i);
            if (i * 2 + 1 < n) {
                TreeNode<Integer> left = list.get(i * 2 + 1);
                parent.left = left;
                left.parent = parent;
            } else
                break;
            if (i * 2 + 2 < n) {
                TreeNode<Integer> right = list.get(i * 2 + 2);
                parent.right = right;
                right.parent = parent;
            }
        }
        return list.get(0);
    }

    private static class TreeNode<T> {
        public T val;
        public TreeNode<T> left = null;
        public TreeNode<T> right = null;
        TreeNode<T> parent;

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

        @Override
        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;

            TreeNode<?> treeNode = (TreeNode<?>) o;

            return val != null ? val.equals(treeNode.val) : treeNode.val == null;
        }

        @Override
        public int hashCode() {
            return val != null ? val.hashCode() : 0;
        }
    }
}