Leetcode - Lowest Common Ancestor of a Binary Tree

Paste_Image.png

My code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private TreeNode ancestor = null;
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null)
            return null;
        else if (p == q)
            return p;
        boolean[] ret = findAncestor(root, p, q);
        return ancestor;
    }
    
    private boolean[] findAncestor(TreeNode root, TreeNode p, TreeNode q) {
        boolean[] retLeft = null;
        boolean[] retRight = null;
        boolean[] ret = new boolean[3];
        
        if (root.left != null) {
            retLeft = findAncestor(root.left, p, q);
            if (retLeft != null) {
                ret[0] |= retLeft[0];
                ret[1] |= retLeft[1];
                ret[2] |= retLeft[2];
                if (ret[2])
                    return ret;
            }
        }
        
        if (root.right != null) {
            retRight = findAncestor(root.right, p, q);
            if (retRight != null) {
                ret[0] |= retRight[0];
                ret[1] |= retRight[1];
                ret[2] |= retRight[2];
                if (ret[2])
                    return ret;
            }
        }
        
        if (root == p)
            ret[0] = true;
        else if (root == q)
            ret[1] = true;
        
        if (ret[0] && ret[1]) {
            ret[2] = true;
            ancestor = root;
        }
        return ret;
    }
}

My test result:

Paste_Image.png

这道题目还是挺带劲的。想了挺久。最后终于写出来，感觉自己功力还是挺深厚的。

首先提醒。
**形参是无法改变实参的，即使传入的是指针。除非是容器。比如这道题目中，
我一开始这么写的函数。

private boolean[] findAncestor(TreeNode root, TreeNode p, TreeNode q， TreeNode ancestor) {....}

然后在主函数中传入ancestor，妄想着在递归中，给他赋值，然后改变实参。也就是主函数中的ancestor。但是，是无法改变的。递归的时候，只是把这个指针的地址压入栈中。如果这个指针取得了新的地址，那么在这段栈里面，他的值会被改变成另外一个地址值。但是这个子函数并没有返回这个地址，那么，当这个子函数结束时，这段地址就被抛弃了。就算他改变了，也不能使上一层的实参指针的地址值发生改变。
什么情况下会改变呢？当实参是容器时，那么传入的容器增减，是可以反映到实参的。
所以，permutation那类题，不能拷贝地址值给arraylist而必须新建一个arraylist拷贝所有元素，然后再添加进大arraylist。同样的，需要不断地remove。
**

这道题目是什么思想呢。
我返回一个三个布尔量的数组。他们的意义是。
boolean[] ret
ret[0] p is find -> true
ret[1] q is find -> true
ret[2] pq is find -> ret[0] & ret[1] == true -> true

然后是用post-order 来遍历的。
因为我发现， pre-order都是先遍历头结点，然后再左再右。
而 post-order 是先遍历子节点，左右，在往上。
所以，当我到达root时，
我先pre order 左子树，
然后看下这个返回的布尔数组，ret[2] 是否为真，如果为真，那么就是已经找到了，我就不需要再找了，直接返回。
如果返回的布尔数组不是空的，但ret[2] false。
那么，我就将 ret[0], ret[1] 与这个布尔数组对应为进行或操作。只要pq有一个被找到，就可以通过或操作反映到ret上。
对右子树进行同样的操作。
然后再判断root自己。是否是pq
再判断下ret[0], ret[1] 是否都为真，如果是的，就代表都找到了，且祖先就是root。
ret[2] 设置为true并返回。
否则就直接返回。

同时，我一开始的代码不是这样的。因为子函数可能返回null，为了避免bug，我就一开始给左右布尔数组都申请了内存。但是想到今早看书，老教授的一句话。
在递归函数中申请内存是一件十分消耗资源的事，能不做就尽量不做。所以我最后找了个办法避免了。多写了几个if语句，所以运行时间可能要慢一点，但是一定省掉了许多内存。

**
总结： post-order tree
**

Anyway, Good luck, Richardo!

My code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) {
            return null;
        }
        else if (root == p || root == q) {
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left == null && right == null) {
            return null;
        }
        else if (left == null || right == null) {
            return left == null ? right : left;
        }
        else {
            return root;
        }
    }
}

同学提醒后做了出来。是一个dfs
bottom up
post-order
如果root == p or q,就返回p or q
否则，继续dfs，再判断返回的左右是否都是空，如果是，就代表p,q不在这个sub tree里面，就返回null
如果有一个为空，则另一个可能是找到的p or q,也可能就是他们的ancestor,直接往上层返回就行。
如果左右都不是空，那么当前root就是ancestor,直接返回root.

思路就是这样的了。

Anyway, Good luck, Richardo! -- 09/05/2016

My code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        HashMap map = new HashMap();
        Stack st = new Stack();
        map.put(root, null);
        st.push(root);
        while (!map.containsKey(p) || !map.containsKey(q)) {
            TreeNode curr = st.pop();
            if (curr.left != null) {
                map.put(curr.left, curr);
                st.push(curr.left);
            }
            if (curr.right != null) {
                map.put(curr.right, curr);
                st.push(curr.right);
            }
        }
        
        HashSet set = new HashSet();
        while (p != null) {
            set.add(p);
            p = map.get(p);
        }
        
        while (q != null) {
            if (set.contains(q)) {
                return q;
            }
            set.add(q);
            q = map.get(q);
        }
        
        return null;
    }
}

reference:
https://discuss.leetcode.com/topic/27479/java-python-iterative-solution/2

这才是真正优美的解决方法。
利用一个map保持父子关系。如果 union find 一般。
然后，利用它，我们还可以找到 p and q 的路径。

Tree + HashMap, 这是一种全新的组合，第一次接触。

Anyway, Good luck, Richardo! -- 09/24/2016