lintcode, 最近公共祖先

最新推荐文章于 2020-12-23 09:37:13 发布

zsjmfy

最新推荐文章于 2020-12-23 09:37:13 发布

阅读量323

点赞数

CC 4.0 BY-SA版权

分类专栏： lintcode 文章标签： lintcode

本文链接：https://blog.youkuaiyun.com/zsjmfy/article/details/53635537

lintcode 专栏收录该内容

98 篇文章

订阅专栏

本文介绍了解决二叉树中寻找两个节点的最近公共祖先（LCA）问题的多种方法，包括递归和非递归（使用链表或栈）实现。提供了详细的算法思路及代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一棵二叉树，找到两个节点的最近公共父节点(LCA)。
最近公共祖先是两个节点的公共的祖先节点且具有最大深度。

解题思路：递归方法采用分别在节点左右子树中查找，返回不为空的那一个。
非递归可以用链表或者栈来存储，然后再查找。
一刷：ac
递归

/**
 * 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 TreeNode lowestCommonAncestor(TreeNode root, TreeNode A, TreeNode B) {
        if(root == null || root == A || root == B) return root;
        TreeNode left = lowestCommonAncestor(root.left, A, B);
        TreeNode right = lowestCommonAncestor(root.right, A, B);
        if(left == null) return right;
        if(right == null) return left;
        return root;
    }
}

非递归，链表，注意边界和恢复状态。

/**
 * 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 TreeNode lowestCommonAncestor(TreeNode root, TreeNode A, TreeNode B) {
        if(root == null || root == A || root == B) return root;
        ArrayList<TreeNode> l1 = new ArrayList<TreeNode>();
        ArrayList<TreeNode> l2 = new ArrayList<TreeNode>();
        findpath(root, A, l1);
        findpath(root, B, l2);
        TreeNode res = root;
        for(int i = 1; i < l1.size() && i < l2.size(); i++){
            if(l1.get(i) == l2.get(i)) res = l1.get(i);
            else break;
        }
        return res;
    }
    public boolean findpath(TreeNode root, TreeNode target, ArrayList<TreeNode> l){
        if(root == null) return false;
        l.add(root);
        if(root == target) return true;
        if(findpath(root.left, target, l) || findpath(root.right, target, l)) return true;
        l.remove(l.size()-1);
        return false;
    }
}

非递归用栈。

/**
 * 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 TreeNode lowestCommonAncestor(TreeNode root, TreeNode A, TreeNode B) {
        if(root == null || root == A || root == B) return root;
        Stack<TreeNode> stack1 = new Stack<TreeNode>();
        Stack<TreeNode> stack2 = new Stack<TreeNode>();
        TreeNode res = root;
        if(findpath(root, A, stack1) && findpath(root, B, stack2)){
            while(!stack1.isEmpty()){
                TreeNode node = stack1.pop();
                if(stack2.contains(node)) res = node;
            }
        }
        return res;
    }

    public boolean findpath(TreeNode root, TreeNode target, Stack<TreeNode> stack){
        if(root == null) return false;
        if(root == target){
            stack.push(root);
            return true;
        }
        if(findpath(root.left, target, stack) || findpath(root.right, target, stack)){
            stack.push(root);
            return true;
        }
        return false;
    }
}