两个链表的第一个公共节点（入门算法26）

题目：输入两个链表，找出它们的第一个公共节点。如下面的两个链表：

在节点 c1 开始相交。

示例：

这里有一个点要特别注意，他要找的是公共节点，意思是，A链表和B链表具有相同的地址空间的节点，而不是节点的val值相等。所以，下面这个示例他的公共节点是8，而不是1。

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

解题思路：
如果他们有公共节点的话，那么他们最后的节点一定是一样的。所以，我们其实可以换个角度思考，从末尾开始遍历两个链表（可以用栈实现），每次相等就保存该节点，直到两个节点的地址空间不同。返回这个节点即可。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        Stack<ListNode> stackA = new Stack<ListNode>();
        Stack<ListNode> stackB = new Stack<ListNode>();
        ListNode result = null;
        //将headA和headB的节点放到栈中，实现两个链表的倒置
        while(headA != null){
            stackA.push(headA);
            headA = headA.next;
        }
        while(headB != null){
            stackB.push(headB);
            headB = headB.next;
        }
        //找出从尾到头第一个不相等的节点
        while(stackA.size() != 0 && stackB.size() != 0){
            if(stackA.peek() == stackB.peek()){
                result = stackA.pop();
                stackB.pop();
            }else   break;
        }
        return result;
    }
}

力扣战绩：

当然了，还有一种更厉害的写法：使用双指针。
让node1等于headA，node2等于headB。然后同时遍历node1和node2直到找到他们的公共节点。这个时候有三种情况，
第一种是A和B的长度相等且存在公共节点，那么当遍历到公共节点的时候，我们可以直接返回node1。
第二种是A和B的长度不相等且存在公共节点，那么第一次遍历，node1和node2肯定不会在公共节点处相交，此时就让node1遍历完A后从B开始遍历，让node2遍历完B后从A开始遍历，这样的话，node1和node2遍历的的总长度就会相等。存在公共节点的话，就一定会同时遍历到该节点，此时我们返回node1。
第三种是A和B不存在公共节点，那么node1和node2肯定都需要遍历一次A和B，最后同时等于null，即node1 == node2 == null。我们返回node1，也就是null。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode node1 = headA;
        ListNode node2 = headB;
        
        while (node1 != node2) {
            node1 = node1 != null ? node1.next : headB;
            node2 = node2 != null ? node2.next : headA;
        }
        return node1;
    }
}

力扣战绩：