Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”
_______3______ / \ ___5__ ___1__ / \ / \ 6 _2 0 8 / \ 7 4
For example, the lowest common ancestor (LCA) of nodes 5
and 1
is 3
. Another example is LCA of nodes 5
and 4
is 5
, since a node can be a descendant of itself according to the LCA definition.
思路:先利用递归遍历算法(先遍历左树)找到一个节点,在遍历的过程中,记录下路径,然后弹栈,找另外一个节点,这时候只用遍历右子树就好,因为找之前一个节点先遍历的是左子树,可以保证遍历过的路径不存在需要寻找的下一个节点,弹栈出的那个节点就是最近公共祖先
因为在找到第一个节点的时候,有可能这个节点存在左子树,所以需要先将这个节点的左子树进行搜索,然后再进行弹栈搜索右子树
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
private Stack<TreeNode> stack=new Stack<TreeNode>();
boolean flag=false;
TreeNode s;
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
getStack(root,p,q);
TreeNode h=stack.pop();
if(find(h.left)||find(h.right)){
return h;
}
while(!stack.isEmpty()){
h=stack.pop();
if(find(h.right)){
return h;
}
}
return null;
}
public boolean find(TreeNode root){
if(root==null){
return false;
}else if(root==s){
return true;
}else{
return find(root.left)||find(root.right);
}
}
public void getStack(TreeNode root,TreeNode p,TreeNode q){
if(flag){
return;
}
if(root==null){
return;
}else if(root==p||root==q){
flag=true;
if(root==p){
s=q;
}else{
s=p;
}
stack.push(root);
}else{
stack.push(root);
getStack(root.left,p,q);
getStack(root.right,p,q);
}
}
}