【每日一算法】相交链表

微信改版，加星标不迷路！

每日一算法 - 相交链表

编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表：

在节点 c1 开始相交。

示例 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 个节点。

 

示例 2：

输入：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 个节点。

 

示例 3：

输入：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。

 

注意：

• 如果两个链表没有交点，返回 null.

• 在返回结果后，两个链表仍须保持原有的结构。

• 可假定整个链表结构中没有循环。

• 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

思路答案

两个链表交叉，其实就是在某一时刻，两个链表指向了同一个节点。那么，如果两个链表等长，这道题就毫无难度了，我们直接分别遍历两个链表，看在哪个节点处，两个链表的指向的节点是一样的。

但是这道题并没有说链表等长，那也好办，我把他们变成等长的。具体思路可以这样描述：

1. 统计两个链表的长度，得到长度差

2. 设置两个指针，分别指向两个链表的头结点

3. 令较长的链表的指针先走与长度差相等的步数，这样一来，如果从现在走到的这个节点开始，同时遍历两个链表，他们第一次指向同一节点时，就是最开始交叉的位置。

那样例来说，令b链表先走一步，到达b2处，从b2开始，同时遍历两个链表，知道两个链表都指向c1时，停止循环，返回c1。

所以，直接写出代码就行：

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode *a = headA;
    struct ListNode *b = headB;
    struct ListNode *tmp = NULL;
    int len_a =0;
    int len_b =0;
    //计算链表a的长度
    while(a) {
        if (a->next) {
            a = a->next;
        } else {
            break;
        }
        len_a++;
        }
    //计算链表b的长度
    while(b) {
        if (b->next) {
            b = b->next;
        } else {
            break;
        }
        len_b++;
    }
  //调整两个链表长度
    a = headA;
    b = headB;
    if (len_a > len_b) {
        int times = len_a - len_b;
        while(times--) {
            a = a->next;
        }
    } else {
        int times = len_b - len_a;
        while(times--) {
            b = b->next;
        }
        
    }
    
    //遍历找出入口
    while (a && b) {
        if(a==b){
           tmp = a;
            break;
        }
        a = a->next;
        b = b->next;
    }
    return tmp;
}

需要注意的地方

一开始做这个题的时候，我把此题当成交叉了之后还会分开做到，所以一直答案不对。。。气到爆炸。最后看了以下别人的代码，我才知道了链表只要是相交了，就不会分开了，因为链表的数据结构中只有一个next节点。（原谅我一开始当成抽象相交，没把他当成链表的实际相交）。

每个算法都是在特定场景下设计的，那么就有朋友会问了，这个算法的意义在哪？意义就在于如果某场景使用两个链表，为了节省空间，则进行链表的公用，如果知道哪个地方开始公用了，就很可以避免因其中一个链表release掉，不影响另外一个链表的正常使用。