20150624 lintcode 总结 Lowest Common Ancestor

二叉树最低公共祖先算法

最新推荐文章于 2021-03-16 18:52:26 发布

原创最新推荐文章于 2021-03-16 18:52:26 发布 · 463 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#lintcode

lintcode 专栏收录该内容

10 篇文章

订阅专栏

本文介绍了一种寻找二叉树中两个指定节点的最低公共祖先(LCA)的算法实现。通过递归搜索的方式找到两个节点的路径，并确定它们共同的最深祖先节点。

Lowest Common Ancestor

http://www.lintcode.com/problem/lowest-common-ancestor

Given the root and two nodes in a Binary Tree. Find the lowest common ancestor(LCA) of the two nodes.

The lowest common ancestor is the node with largest depth which is the ancestor of both nodes.

Have you met this question in a real interview?

Example For the following binary tree:

LCA(3, 5) = 4 LCA(5, 6) = 7LCA(6, 7) = 7

Solution:

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */

public class Solution {
    /**
     * @param root: The root of the binary search tree.
     * @param A and B: two nodes in a Binary.
     * @return: Return the least common ancestor(LCA) of the two nodes.
     */
	
	public ArrayList<TreeNode> temp_As = new ArrayList<TreeNode>();
	public ArrayList<TreeNode> A_s = new ArrayList<TreeNode>();
	public ArrayList<TreeNode> B_s = new ArrayList<TreeNode>();

	public boolean isContained(TreeNode root, TreeNode A){
	    if(root==null){
	    	return false;
	    }
		if(root==A){
			temp_As.add(root);
			return true;
		}
		if(isContained(root.left, A)||isContained(root.right,A)){
			temp_As.add(root);
			return true;
		}
		return false;
	}	
	
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode A, TreeNode B) {
        // write your code here
    	isContained(root, A);       
        for(int i = 0; i<temp_As.size(); i++){
        	A_s.add(temp_As.get(temp_As.size()-1-i));
        }
        temp_As.clear();
        
        isContained(root, B);        
        for(int i = 0; i<temp_As.size(); i++){
        	B_s.add(temp_As.get(temp_As.size()-1-i));
        }
        temp_As.clear();
        
        int i = 0;
        for(; i < Math.min(A_s.size(), B_s.size()); i++){
            if(A_s.get(i)!= B_s.get(i)){
                break;
            }
        }
        i= i>0?i-1:0;        
        return A_s.get(i);
        
    }

}