【面试题】两个链表的第一个公共节点（两种解法）

题目描述

解法一：剑指offer上的题解

首先遍历两个链表得到它们的长度,就能知道哪个链表比较长,以及长的链表比短的链表多几个节点。

在第二次遍历的时候,在较长的链表上先走若干步,接着同时在两个链表上遍历,找到的第一个相同的节点就是它们的第一个公共节点。

时间复杂度为O(m+n)，m、n分别为两个链表的长度。
空间复杂度为O(1)，只使用了几个常量（三个int，两个ListNode）。

Java

/**
 * 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) {
        // 如果某一链表为空，肯定不存在公共节点
        if(headA == null || headB == null) return null; 
        // 得到两个链表的长度
        int lenA = GetListLength(headA);
        int lenB = GetListLength(headB);
        int diff; // 记录长度差
        ListNode headLong, headShort; // 定义两个
        if(lenA >= lenB){
            diff = lenA - lenB;
            headLong = headA;
            headShort = headB;
        }           
        else {
            diff = lenB - lenA;
            headLong = headB;
            headShort = headA;
        }
        // 先在长链表中走若干步，直到剩余部分和短链表长度一致
        for(int i=0; i<diff; i++) { 
            headLong = headLong.next; 
        }
        // 再同时在两个链表上遍历，找到的第一个相同节点即为第一个公共节点
        while(headLong != null && headShort != null && headLong != headShort) {
            headLong = headLong.next;
            headShort = headShort.next;
        }
        /*
        由于此时两个链表待遍历的长度一致;
        如果相交，headLong和 headShort都会指向首个公共节点;
        如果不相交，headLong和 headShort都会指向 null;
        故最后返回 headLong即可。
        */
        return headLong; 
    }

    public int GetListLength(ListNode head) { // 计算链表长度
        int ListLength = 0;
        while(head != null) {
            head = head.next;
            ListLength++;
        }
        return ListLength;
    }
}

解法二：双指针相遇法

参考这个解题思路
使用两个指针 node1，node2 分别指向两个链表 headA，headB 的头结点，然后同时分别逐结点遍历；
当 node1 到达链表 headA 的末尾时，重新定位到链表 headB 的头结点；
当 node2到达链表 headB的末尾时，重新定位到链表 headA的头结点；
这样，当它们相遇时，所指向的结点就是第一个公共结点。

上述思路其实可以这样理解：
两个有公共节点而部分重合的链表构成的 Y形结构的长度是固定的，即前面两个分叉部分(可能长度不一) + 后边一个重合部分(若不存在重合节点时，则后半部分的长度为0)。
对于 node1，其先走 headA 对应的分叉和重合部分(若有的话)，即遍历链表 A的全部节点，之后从 headB开始，走剩下的那个分叉。
对于 node2,其先走 headB 对应的分叉和重合部分(若有的话)，即全部的链表B的长度，之后从 headA开始，走剩下的那个分叉。
由于 Y形结构的长度是固定的，两指针又是同时开始，步速一致，若存在重合节点，两者最终一定可以汇合。

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; // 若遍历完链表 A则从链表 B开始继续走
            node2 = (node2 != null) ? node2.next : headA; // 若遍历完链表 B则从链表 A开始继续走
        }
        return node1; // 若有重合，最终一定会相遇，node1和 node2均指向公共节点，否则 node1和 node2均为空
    }
}