160. Intersection of Two Linked Lists

▶ 有两个单链表，从中间某个节点开始结点完全相同，找出该节点。

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:    b1 → b2 → b3

● 神奇的双指针法，34 ms，，详细步骤见代码注释（设两个单链表结点个数分别为 m 和 n，公共部分长为 k），时间复杂度 O(n)，空间复杂度 O(1)

class Solution
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
    {
        if (headA == nullptr || headB == nullptr)
            return nullptr;
        ListNode *pa, *pb;
        for (pa = headA, pb = headB; pa != pb;) // 两指针分别指向两个单链表头部，每次循环将两指针向后一移一个结点
        {
            if (pa->next == nullptr && pb->next == nullptr)// 两个指针同时为空指针，说明两单链表没有公共结点（发生在第 m + n + 1 次循环）
                return nullptr;
            pa = pa->next, pb = pb->next;       // 两指针分别向后移动一个结点
            if (pa == nullptr)                  // 其中一个指针超出某一条单链表的尾部的时候，让它指向另一条单链表的头部
                pa = headB;
            if (pb == nullptr)
                pb = headA;
        }
        return pa;                              // 两指针指向同一结点的时候，该节点就是公共链表部分的头结点（发生在第 m + n - k + 1 次循环）
    }
};

● 双指针法高压版，36 ms

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
{
    ListNode *cur1, *cur2;
    for(cur1 = headA, cur2 = headB;cur1 != cur2;)
    {
        cur1 = cur1 ? cur1->next : headB;
        cur2 = cur2 ? cur2->next : headA;
    }
    return cur1;
}

 ● 代码，55 ms，便于理解的一个双指针法，加上蜜汁优化以后 24 ms，时间复杂度 O(n)

static int x = []() 
{    
    std::ios::sync_with_stdio(false);   // 关闭 cout 和 cin，使用 printf 和 scanf
    cin.tie(NULL);                      // 解除绑定 cin 和 cout
    return 0;
} ();

class Solution
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
    {
        ListNode *cur1, *cur2;        
        int la, lb, diff;
        for (la = 0, cur1 = headA; cur1 != nullptr; cur1 = cur1->next, la++);// 统计两单链表的结点数 
        for (lb = 0, cur2 = headB; cur2 != nullptr; cur2 = cur2->next, lb++);
        cur1 = headA, cur2 = headB;
        diff = abs(la - lb);
        if (la > lb)
            for (; diff > 0; cur1 = cur1->next, diff--);            // 把公共结点之前不等长的部分跳过
        else
            for (; diff > 0; cur2 = cur2->next, diff--);
        for (; cur1 != cur2; cur1 = cur1->next, cur2 = cur2->next); // 共同前进直到两指针指向的结点相同，即为公共单链表头结点 
        return cur1;
    }
};

● 代码，35 ms，强改指针地址

class Solution//35
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
    {
        ListNode *cur, *result;
        unsigned long *ptr;
        for (cur = headA; cur != nullptr;)// 默认结点二进制地址的末位为 0，把单链表 a 中各节点的 next 值二进制末位强行改成 1
        {
            ptr = (unsigned long *)&cur->next;
            cur = cur->next;
            *ptr |= 1;
        }
        for (cur = headB, result = nullptr; cur; cur = cur->next)// 沿着单链表 b 寻找 next 值被修改的结点，即为公共单链表的头结点 
        {
            if ((unsigned long)cur->next & 1)
            {
                result = cur;
                break;
            }
        }
        for (cur = headA; cur; cur = cur->next)// 把单链表 a 中各节点的 next 值改回去
        {
            ptr = (unsigned long *)&cur->next;
            *ptr &= (~0ULL << 1);
        }
        return result;
    }
};

● 代码，38 ms，强改指针地址高压版，注释为等价的改地址方法

class Solution//38
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
    {
        if (headA == nullptr || headB == nullptr)
            return NULL;
        ListNode **pp, *q;
        for (pp = &(headA->next); (*(long*)pp |= 1L) != 1L;)            
            pp = &(((ListNode*)((char*)*pp - 1))->next);    // pp = (ListNode**)((char*)*pp - 1 + sizeof(int));
        for (q = headB; q != NULL && !((long)(q->next) & 1L); q = q->next);        
        for(pp = &(headA->next); (*(long*)pp &= -2L) != 0L;)            
            pp = &((*pp)->next);                            // pp = (ListNode**)((char*)*pp + sizeof(int));
        return q;
    }
};

 ● 其他方法：暴力枚举，逐对检验，时间复杂度 O(mn)，空间复杂度 O(1)；其中一支单链表加入 hash 表，依另一支来查找，时间复杂度 O(m+n)，空间复杂度 O(m) 或 O(n)