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.

python

"""
Definition of ParentTreeNode:
class ParentTreeNode:
    def __init__(self, val):
        self.val = val
        self.parent, self.left, self.right = None, None, None
"""
class Solution:
    """
    @param root: The root of the tree
    @param A and B: Two node in the tree
    @return: The lowest common ancestor of A and B
    """ 
    def lowestCommonAncestorII(self, root, A, B):
        # Write your code here
        arrayA = []
        arrayB = []
        self.findNode(root, A, arrayA)
        self.findNode(root, B, arrayB)
        indexA, indexB = len(arrayA) - 1, len(arrayB) - 1
        while indexA >= 0 and indexB >= 0:
            if arrayA[indexA] != arrayB[indexB]:
                return arrayA[indexA + 1]
            indexA -= 1
            indexB -= 1
        if indexA < 0:
            return arrayA[0]
        else:
            return arrayB[0]
    def findNode(self, root, node, array):
        array.append(node)
        if node == root:
            return
        self.findNode(root, node.parent, array)

java

/**
 * Definition of ParentTreeNode:
 * 
 * class ParentTreeNode {
 *     public ParentTreeNode parent, left, right;
 * }
 */
public class Solution {
    /**
     * @param root: The root of the tree
     * @param A, B: Two node in the tree
     * @return: The lowest common ancestor of A and B
     */
    public ParentTreeNode lowestCommonAncestorII(ParentTreeNode root,
                                                 ParentTreeNode A,
                                                 ParentTreeNode B) {
        // Write your code here 
        if (root == null) {
            return null;
        }
        List<ParentTreeNode> listA = new ArrayList<>();
        List<ParentTreeNode> listB = new ArrayList<>();
        findNode(A, root, listA);
        findNode(B, root, listB);
        Collections.reverse(listA);
        Collections.reverse(listB);
        int i;
        for (i = 0; i < Math.min(listA.size(), listB.size()); i++) {
            if (listA.get(i) != listB.get(i)) {
                return listA.get(i - 1);
            }
        }
        return listA.get(i - 1);
    }
    private void findNode(ParentTreeNode node,
                          ParentTreeNode root,
                          List<ParentTreeNode> list) {
        list.add(node);
        if (node == root) {
            return;
        }
        findNode(node.parent, root, list);
    }
}