*lintcode578- Lowest Common Ancestor III- medium

最新推荐文章于 2025-05-26 00:26:50 发布

转载最新推荐文章于 2025-05-26 00:26:50 发布 · 108 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/jasminemzy/p/7655585.html

本文介绍了一种寻找二叉树中两个节点的最低公共祖先(LCA)的有效算法。通过递归遍历树结构，并利用辅助类ResultType记录节点信息，确保能够正确找到存在或不存在目标节点的情况下的LCA。

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.
Return null if LCA does not exist.

Notice

node A or node B may not exist in tree.

Example

For the following binary tree:

LCA(3, 5) = 4

LCA(5, 6) = 7

LCA(6, 7) = 7

最普适的版本。用resultType作为辅助，包含hasA,hasB,和node。和一开始的方法完全没有区别，只是要一层层把整棵树里面有没有AB的信息返到最顶层，从而最顶层调用helper的时候根据有没有AB来判断这个node能不能用（有AB则是正确的LCA，没有AB则只是把A或者B返了上来）。

/**
 * 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 tree.
     * @param A: A TreeNode
     * @param B: A TreeNode
     * @return: Return the LCA of the two nodes.
     */
     
    private class ResultType{
        public boolean hasA, hasB;
        public TreeNode node;
        public ResultType(boolean hasA, boolean hasB, TreeNode node) {
            this.hasA = hasA;
            this.hasB = hasB;
            this.node = node;
        }
    }
    
    public TreeNode lowestCommonAncestor3(TreeNode root, TreeNode A, TreeNode B) {
        // write your code here
        ResultType result = findNode(root, A, B);
        if (result.hasA && result.hasB) {
            return result.node;
        }
        return null;
    }
    
    //ding yi定义
    //1. if has A, set hasA
    //2. if has B, set hasB
    //3. if (left.hasA&&right.hasB) || (left.hasB&&right.hasA) lca = root;
    private ResultType findNode(TreeNode root, TreeNode A, TreeNode B) {
        
        if (root == null) {
            return new ResultType(false, false, null);
        }
        
        ResultType left = findNode(root.left, A, B);
        ResultType right = findNode(root.right, A, B);
        
        boolean crtHasA = left.hasA || right.hasA || root == A;
        boolean crtHasB = left.hasB || right.hasB || root == B;
        
        if (root == A || root == B) {
            return new ResultType(crtHasA, crtHasB, root);
        }
        
        
        if (left.node != null && right.node != null) {
            return new ResultType(crtHasA, crtHasB, root);
        }
        
        if (left.node != null) {
            return new ResultType(crtHasA, crtHasB, left.node);
        }
        
        if (right.node != null) {
            return new ResultType(crtHasA, crtHasB, right.node);
        }
        
        return new ResultType(crtHasA, crtHasB, null);
    }
}

转载于:https://www.cnblogs.com/jasminemzy/p/7655585.html