给定两个二叉树的节点node1和node2，找到他们的最低公共祖先节点

class Node{
    
    
    Integer data;
    Node left;
    Node right;

    public Node(int data) {
    
    
        this.data = data;
    }

    @Override
    public boolean equals(Object o) {
    
    
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Node node = (Node) o;
        return Objects.equals(data, node.data);
    }

    @Override
    public int hashCode() {
    
    
        return Objects.hash(data);
    }
}

方法一：

    /**
     * 给定二叉树的两个节点node1和node2，找出这两个节点的最低公共子节点
     * 方法一：
     *      1.将这颗二叉树遍历一遍，使用map装起来，Map<当前节点，父节点>
     *      2.使用node1节点，向上查找，将路径经过的节点都加入set中，接着node2向上查找，查找过程中判断set中是否存在查找的元素
     *        如果set中存在，那么这个节点就是node1和node2的最低公共子节点
     * @return
     * @param root
     * @param o1
     * @param o2
     */
    private static Node findFatherNode(Node root, Node o1, Node o2) {
    
    
        // <当前节点，父节点>
        Map<Node, Node> map = new HashMap<>();

        map.put(root, root);
        process(root, map);

        Set<Node> nodes = new HashSet<>();

        // 节点node1的父路径节点加入set中
        Node fatherNode = map.get(o1);
        while(!o1.equals(fatherNode)){
    
    
            nodes.add(o1);
            o1 = fatherNode;
            fatherNode = map.get(o1);
        }
        nodes.add(fatherNode);

        // node2向上查找，并判断
        while(!nodes.contains(o2)){
    
    
            o2 = map.get(o2);
        }
        return o2;
    }
    
    // 遍历二叉树，并将节点存在map<当前节点，父节点>中
    private static void process(Node root, Map<Node, Node> map) {
    
    
        if(root == null){
    
    
            return;
        }
        map.put(root.left, root);
        map.put(root.right, root);
        process(root.left, map);
        process(root.right, map);
    }

方法二：

    /**
     * 给定二叉树的两个节点node1和node2，找出这两个节点的最低公共子节点
     * 方法二：
     *   1.node1和node2节点位于同一条路径上
     *   2.node1和node2节点位于不同的路径上
     * @param root
     * @param o1
     * @param o2
     * @return
     */
    private static Node findFatherNode2(Node root, Node o1, Node o2) {
    
    
        // 如果节点为空 或者 当前节点==node1节点 或者 当前节点==node2节点，则返回自身
        if(root == null || root.equals(o1) || root.equals(o2)){
    
    
            return root;
        }
        Node leftNode = findFatherNode2(root.left, o1, o2);
        Node rightNode = findFatherNode2(root.right, o1, o2);

        // 找到目标节点(最低公共祖子节点)
        if(leftNode != null && rightNode != null){
    
    
            return root;
        }
        // 左节点和右节点哪个不为空就返回谁
        return leftNode != null ? leftNode : rightNode;
    }