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:
这道题目还是挺带劲的。想了挺久。最后终于写出来，感觉自己功力还是挺深厚的。
首先提醒。
**形参是无法改变实参的，即使传入的是指针。除非是容器。比如这道题目中，
我一开始这么写的函数。
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<TreeNode, TreeNode> map = new HashMap<TreeNode, TreeNode>();
Stack<TreeNode> st = new Stack<TreeNode>();
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<TreeNode> set = new HashSet<TreeNode>();
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
