236. Lowest Common Ancestor of a Binary Tree

一、题目

　　1、审题

　　

　　2、分析

　　　　求二叉树中 p、q 节点的最小共同祖先节点。

二、解答

　　1、思路

　　　　方法一、

　　　　　　采用循环查找。

　　　　　　①、若 root 为 p 或者 q ，则返回 root

　　　　　　②、若 p、q 分布在 root 不同的左右子树，则返回 root

　　　　　　③、若 p、q 均为 root 左子树，则 root = root.left； 若 p、q均在右子树，则 root = root.right。

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while(root != null) {
            if(root.val == p.val || root.val == q.val)
                return root;
            
            boolean pInLeft = isChildren(root.left, p);
            boolean qInRight = isChildren(root.right, q);

            if((pInLeft && qInRight) || (!pInLeft && !qInRight))
                return root;
            
            if(pInLeft)    // p、q 均在 left
                root = root.left;
            else     // p、q 均在 right
                root = root.right;
        }
        return null;
    }
    
    private boolean isChildren(TreeNode root, TreeNode p) {
        TreeNode node = root;
        while(node != null) {
            if(node.val == p.val)
                return true;
            else 
                return isChildren(root.left, p) || isChildren(root.right, p);
        }
        return false;
    }

　　方法二、

　　　　采用递归查找。

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q)
            return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if(left == null)
            return right;
        if(right == null)
            return left;
        // 分别在左右子树
        return root;
    }

　　方法三、

　　　　采用 Map 存储每个节点和该节点的父节点。

　　　　最终采用 Set 存储 p 的所有祖先节点，q依次向祖先节点移动，找出第一次出现在 Set 中的节点即为 p、q 最小祖先节点。

　　public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        HashMap<TreeNode, TreeNode> parent = new HashMap<>();
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        parent.put(root, null);
        stack.push(root);
        
        // paretn 同时包含 p、q 则跳出循环 
        while(!parent.containsKey(p) || !parent.containsKey(q)) {
            TreeNode node = stack.pop();
            if(node.left != null) {
                parent.put(node.left, node);
                stack.push(node.left);
            }
            
            if(node.right != null) {
                parent.put(node.right, node);
                stack.push(node.right);
            }
        }
        
        Set<TreeNode> ancestors = new HashSet<>();
        while(p != null) {
            ancestors.add(p);
            p = parent.get(p);
        }
        while(!ancestors.contains(q)) 
            q = parent.get(q);
        return q;
    }