LeetCode LCA问题

//**************** 12. Lowest Common Ancestor II ***************
/*
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.
The node has an extra attribute parent which point to the father of itself. The root's parent is null.
*/
// 转换成列表求解

public class Solution {
    public ParentTreeNode lowestCommonAncestorII(ParentTreeNode root, ParentTreeNode A, ParentTreeNode B) {
        if (root == null) {
            return null;
        }
        if (A == root || B == root) {
            return root;
        }
        ArrayList<ParentTreeNode> listA = findParent(A);
        ArrayList<ParentTreeNode> listB = findParent(B);
        int indexA = listA.size() - 2;
        int indexB = listB.size() - 2;
        while (indexA >= 0 && indexB >= 0) {
            if (listA.get(indexA) != listB.get(indexB)) {
                return listA.get(indexA + 1);
            }
            indexA--;
            indexB--;
        }
        return indexA < 0 ? listA.get(0) : listB.get(0);
    }
    private ArrayList<ParentTreeNode> findParent(ParentTreeNode node) {
        ArrayList<ParentTreeNode> list = new ArrayList<>();
        while (node != null) {
            list.add(node);
            node = node.parent;
        }
        return list;
    }
}

// follow up
// 没有parent指针

public class Solution {
    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 && right != null) {
            return root;
        }
        if (left != null) {
            return left;
        }
        if (right != null) {
            return right;
        }
        return null;
    }
}

// follow up
// 可能不存在的元素

public class Solution {
    public TreeNode lowestCommonAncestor3(TreeNode root, TreeNode A, TreeNode B) {	
        if (root == null) {
            return null;
        }
        if (!isHave(root, A) || !isHave(root, B)) {
            return null;
        }
        return LCA(root, A, B);
    }
    
    private TreeNode LCA(TreeNode root, TreeNode A, TreeNode B) {
        if (root == null || root == A || root == B) {
            return root;
        }
        TreeNode left = LCA(root.left, A, B);
        TreeNode right = LCA(root.right, A, B);
        if (left != null && right != null) {
            return root;
        }
        if (left != null) {
            return left;
        }
        if (right != null) {
            return right;
        }
        return null;
    }
    
    private boolean isHave(TreeNode root, TreeNode node) {
        if (root == null) {
            return false;
        }
        if (root == node) {
            return true;
        }
        boolean left = isHave(root.left, node);
        boolean right = isHave(root.right, node);
        return left || right;
    }
}