java求最近的共同祖先节点_剑指offer（java）：求树中两个结点的最低公共祖先...

题目：

树中两个节点的最低公共祖先。

最近公共祖先简称LCA(Lowest Common Ancestor)，所谓LCA，是当给定一个有根树T时，对于任意两个结点u、v，找到一个离根最远的结点x，使得x同时是u和v的祖先，x 便是u、v的最近公共祖先。

思路一：

输入两个树节点，求他们的最低公共祖先，

——如果是二叉树，而且是二叉搜索树，那么是可以找到公共节点的。

二叉搜索树都是排序过的，位于左子树的节点都比父节点小，而位于右子树上面的节点都比父节点大。

如果当前节点的值比两个结点 的值都大，那么最低的共同的父节点一定是在当前节点的左子树中，于是下一步遍历当前节点的左子节点。

如果当前节点的值比两个结点的值都小，那么最低的共同的父节点一定是在当前节点的右子树中，于是下一步遍历当前节点的右子节点。

这样从上到下，找到的第一个在两个输入结点的值之间的节点，就是最低的公共祖先。

package cglib;

class TreeNode {

int data;

TreeNode left;

TreeNode right;

}

public class List1

{

public static TreeNode getLastCommonParent(TreeNode root,TreeNode a,TreeNode b)

{

if (root==null || a==null || b==null)

return null;

while (root != null) {

if (root.data > a.data  && root.data  > b.data )

root = root.left;

else if (root.data < a.data && root.data < b.data)

root = root.right;

else

return root;

}

return null;

}

public static void main(String args[]){

TreeNode n1 = new TreeNode();

TreeNode n2 = new TreeNode();

TreeNode n3 = new TreeNode();

TreeNode n4 = new TreeNode();

TreeNode n5 = new TreeNode();

TreeNode n6 = new TreeNode();

TreeNode n7 = new TreeNode();

n1.left=n2;

n1.right=n3;

n2.left=n4;

n2.right=n5;

n3.left=n6;

n3.right=n7;

n1.data=10;

n2.data=8;

n3.data=13;

n4.data=4;

n5.data=9;

n6.data=12;

n7.data=17;

// 搜索二叉树

//              10

//           /       \

//         8         13

//        /  \       /     \

//      4    9  12    17

System.out.println(n1.data);

System.out.println(n6.data);

System.out.println(n7.data);

TreeNode parent=getLastCommonParent(n1, n6, n7);

System.out.println(parent.data);

}

}

输出：

10

12

17

13

思路二：

如果这棵树是普通的树，而且树中结点没有指向父结点的指针，解法如下：

思路三：

我们可以用深度优先搜索，从叶子节点向上，标记子树中出现目标节点的情况。如果子树中有目标 节点，标记为那个目标节点，如果没有，标记为null。显然，如果左子树、右子树都有标记，说明就已经找到最小公共祖先了。如果在根节点为p的左右子树中 找p、q的公共祖先，则必定是p本身。

换个角度，可以这么想：如果一个节点左子树有两个目标节点中的一个，右子树没有，那这个节点 肯定不是最小公共祖先。如果一个节点右子树有两个目标节点中的一个，左子树没有，那这个节点肯定也不是最小公共祖先。只有一个节点正好左子树有，右子树也 有的时候，才是最小公共祖先。

package cglib;

class TreeNode {

int data;

TreeNode left;

TreeNode right;

}

public class List1

{

//两个节点的最低公共祖先，参数为两个节点

public static TreeNode getLastCommonParent(TreeNode root,TreeNode a,TreeNode b)

{

//发现目标节点则通过返回值标记该子树发现了某个目标结点

//如果在根节点为a的左右子树中找a、b的公共祖先，则必定是a本身。

//同理，如果在根节点为b的左右子树中找a、b的公共祖先，则必定是b本身。

if (root == null || root == a || root == b)

return root;

//查看左子树中是否有目标结点，没有为null

TreeNode left = getLastCommonParent(root.left, a, b);

//查看右子树是否有目标节点，没有为null

TreeNode right = getLastCommonParent(root.right, a, b);

//都不为空，说明左右子树都有目标结点，则公共祖先就是本身

if (left != null&&right != null)

return root;

//如果发现了目标节点，则继续向上标记为该目标节点

return left == null ? right : left;

}

public static void main(String args[]){

TreeNode n1 = new TreeNode();

TreeNode n2 = new TreeNode();

TreeNode n3 = new TreeNode();

TreeNode n4 = new TreeNode();

TreeNode n5 = new TreeNode();

TreeNode n6 = new TreeNode();

TreeNode n7 = new TreeNode();

n1.left=n2;

n1.right=n3;

n2.left=n4;

n2.right=n5;

n3.left=n6;

n3.right=n7;

n1.data=1;

n2.data=2;

n3.data=3;

n4.data=4;

n5.data=5;

n6.data=6;

n7.data=7;

// 搜索二叉树

//            1

//          /   \

//         2     3

//        / \   / \

//      4    5 6   7

System.out.println(n1.data);

System.out.println(n6.data);

System.out.println(n7.data);

TreeNode parent=getLastCommonParent(n1, n6, n7);

System.out.println(parent.data);

}

}

输出：

1

6

7

3

以上解法需要对同一个结点重复遍历很多次，效率较低，如果允许使用辅助内存，则可以有效率更高的方法，解法如下：

package cglib;

import java.util.Stack;

class TreeNode {

int data;

TreeNode left;

TreeNode right;

}

public class List1

{

public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q){

Stack stackp = new Stack();

Stack stackq = new Stack();

getPath(root, p, stackp);

getPath(root, q, stackq);

return lowestCommonAncestor(stackp, stackq);

}

private static TreeNode lowestCommonAncestor(Stack stackp, Stack stackq)    {

TreeNode target = null;

while (!stackp.isEmpty() && !stackq.isEmpty() && stackp.peek() == stackq.peek())

{

target = stackp.peek();

stackp.pop();

stackq.pop();

}

return target;

}

private static boolean getPath(TreeNode root, TreeNode p, Stack stackp)    {

// TODO Auto-generated method stub

if (root == null)

return false;

if (root == p)

{

stackp.push(root);

return true;

}

else

{

if (getPath(root.left, p, stackp) || getPath(root.right, p, stackp))

{

stackp.push(root);

return true;

}

}

return false;

}

/***

*

* 这个代码在实现过程中，是当找到给定节点的时候才将路径依次压入stack中的，

* 也就是说，两个stack的栈顶都是存放着root节点。

* 因此，此时就应该找两条路径分离开之前的最后一个节点，

* 此节点就是所求的最低公共祖先。

* @param args

*/

public static void main(String args[]){

TreeNode n1 = new TreeNode();

TreeNode n2 = new TreeNode();

TreeNode n3 = new TreeNode();

TreeNode n4 = new TreeNode();

TreeNode n5 = new TreeNode();

TreeNode n6 = new TreeNode();

TreeNode n7 = new TreeNode();

n1.left=n2;

n1.right=n3;

n2.left=n4;

n2.right=n5;

n3.left=n6;

n3.right=n7;

n1.data=1;

n2.data=2;

n3.data=3;

n4.data=4;

n5.data=5;

n6.data=6;

n7.data=7;

// 搜索二叉树

//            1

//          /   \

//         2     3

//        / \   / \

//      4    5 6   7

System.out.println(n1.data);

System.out.println(n6.data);

System.out.println(n7.data);

TreeNode parent=lowestCommonAncestor(n1, n6, n7);

System.out.println(parent.data);

}

}

输出：

1

6

7

3