比如这颗树，给定2个节点: 4、5 ，它们的最近公共祖先节点为2。类似的，如果是3、5，它们的最近公共祖先节点为1。
一种比较容易想到的思路，如果知道每个节点到root的全路径， 比如
3到root节点的全路径为: 3->1
5到root节点的全路径为: 5->2->1
这样，只要遍历对比下全路径， 就能知道最近的公共节点是1，求每个节点到根节点全路径的方法，在以前的文章算法练习(11)-二叉树的各种遍历 有详细代码，此处直接复用即可。
/**
* 获取每个节点到根节点的全路径
*
* @param node
* @return
*/
public static Map<TreeNode, List<TreeNode>> getToRootPath(TreeNode node) {
if (node == null) {
return null;
}
//记录每个节点->父节点的1:1映射
Map<TreeNode, TreeNode> parentMap = new HashMap<>();
Queue<TreeNode> queue = new LinkedList<>();
queue.add(node);
parentMap.put(node, null);
while (!queue.isEmpty()) {
TreeNode n = queue.poll();
if (n.left != null) {
queue.add(n.left);
parentMap.put(n.left, n);
}
if (n.right != null) {
queue.add(n.right);
parentMap.put(n.right, n);
}
}
//根据parentMap，整理出完整的到根节点的全路径
Map<TreeNode, List<TreeNode>> result = new HashMap<>();
for (Map.Entry<TreeNode, TreeNode> entry : parentMap.entrySet()) {
TreeNode self = entry.getKey();
TreeNode parent = entry.getValue();
//把当前节点，先保护起来
TreeNode temp = self;
List<TreeNode> path = new ArrayList<>();
while (parent != null) {
path.add(self);
self = parent;
parent = parentMap.get(self);
if (parent == null) {
path.add(self);
}
}
result.put(temp, path);
}
return result;
}
/**
* 求节点n1,n2的最近公共祖先
* @param root
* @param n1
* @param n2
* @return
*/
public static TreeNode getNearestSameParentNode(TreeNode root, TreeNode n1, TreeNode n2) {
if (n1 == null || n2 == null) {
return n1 == null ? n2 : n1;
}
if (n1.equals(n2)) {
return n1;
}
Map<TreeNode, List<TreeNode>> path = getToRootPath(root);
List<TreeNode> n1Path = path.get(n1);
List<TreeNode> n2Path = path.get(n2);
for (TreeNode node1 : n1Path) {
for (TreeNode node2 : n2Path) {
if (node1.equals(node2)) {
return node1;
}
}
}
return null;
}
public static void main(String[] args) {
TreeNode n1 = new TreeNode(1);
TreeNode n2_1 = new TreeNode(2);
TreeNode n2_2 = new TreeNode(3);
TreeNode n3_1 = new TreeNode(4);
TreeNode n3_2 = new TreeNode(5);
TreeNode n4_1 = new TreeNode(6);
TreeNode n4_2 = new TreeNode(7);
n1.left = n2_1;
n1.right = n2_2;
n2_1.left = n3_1;
n2_1.right = n3_2;
n2_2.left = n4_1;
n2_2.right = n4_2;
TreeNode result1 = getNearestSameParentNode(n1, n4_1, n4_2);
System.out.println(n4_1 + "/" + n4_2 + " : " + result1);
TreeNode result2 = getNearestSameParentNode(n1, n2_2, n3_2);
System.out.println(n2_2 + "/" + n3_2 + " : " + result2);
TreeNode result3 = getNearestSameParentNode(n1, n2_1, n3_1);
System.out.println(n2_1 + "/" + n3_1 + " : " + result3);
}
输出：
6/7 : 3 3/5 : 1 2/4 : 2
这个方法，虽然思路很容易理解 ，但效率并不高， 额外空间借助了2个Map，空间复杂度至少也是O(N)级别，然后再做2轮循环比较全路径，时间复杂度也可以优化，事实上有更好的解法：
public static TreeNode getNearestSameParentNode(TreeNode root, TreeNode n1, TreeNode n2) {
if (root == null || root == n1 || root == n2) {
return root;
}
TreeNode left = getNearestSameParentNode(root.left, n1, n2);
TreeNode right = getNearestSameParentNode(root.right, n1, n2);
if (left != null && right != null) {
return root;
}
return left != null ? left : right;
}
这个代码很短， 但不太好理解 ， 先分析下一颗树中的2个节点X、Y，它们最近公共祖先的情况：
只会出现这2类情况：
1、节点X在Y的某1侧子树中（反过来也一样， Y出现在X的某1侧子树中），即：1个节点就是另1个的最近公共祖先。
2、节点X与Y，必须向上汇聚， 才能走到1个最近的交叉节点
在优化版的代码中，使用了递归求解。
第1段if判断，其实有2层意思，用于处理递归过程中的边界返回：
if (root == null || //递归到最末端叶节点时的函数返回
(root == n1 || root == n2) //在左右子树遍历过程中，如果发现当前节点就是n1或n2，直接返回，因为下面的子节点，肯定不可能再是它俩的公共祖先节点了
) {
return root;
}
最后1段return，表示遍历过程中，如果X或Y只出现在左子树中或右子树中，哪边出现就返回哪边，相当于下图这种情况，返回的是X，另1侧的返回null被扔掉.
return left != null ? left : right;
中间一段if，则表示是情况2：
if (left != null && right != null) {
return root;
}
在遍历的过程中，如果X与Y出现在某1个节点的2侧，最后左、右子树的遍历中， 会把它俩都返回过来，出现这种情况，说明X与Y汇聚于当前节点，这个节点就是最近的公共祖先。