LeetCode 面试题 02.07. 链表相交 【知识点：双指针，堆栈】

题目

来源：力扣（LeetCode）
链接：面试题 02.07. 链表相交
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘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
输出：Intersected at ‘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 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 0 <= m, n <= 3 * 104
• 1 <= Node.val <= 105
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

**进阶：**你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？

解题

方法一：暴力枚举

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
  
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    struct ListNode *p,*q;

    for(p=headA;p;p=p->next){
        for(q=headB;q;q=q->next){

            if(p == q){
                goto HERE;
            }
        }
    }

    HERE: return p;
}

时间复杂度O(m*n)，空间复杂度O(1)

方法二：堆栈

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

#define MAXNUMS 30001

typedef struct _Stack{
    struct ListNode* Array[MAXNUMS];
    int Top;
}Stack;

void Push( Stack* S,struct ListNode* p )
{
    S->Top++;

    if(S->Top < MAXNUMS){
        S->Array[S->Top] = p;
    } 
}

struct ListNode* Pop( Stack* S )
{
    return S->Array[S->Top--];
}

bool isEmpty ( Stack* S )
{
    return S->Top == -1 ? true : false;
}

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    if(headA == NULL || headB == NULL){
        return NULL;
    }

    Stack* A = malloc(sizeof(Stack));
    A->Top = -1;

    Stack* B = malloc(sizeof(Stack));
    B->Top = -1;

    struct ListNode *p,*q;

    p = headA;
    while(p){
        Push( A,p );
        p = p->next;
    }

    q = headB;
    while(q){
        Push( B,q );
        q = q->next;
    }

    struct ListNode *ans;
    p = q = NULL;

    while( p == q && !isEmpty( A ) && !isEmpty( B ) ){
        ans = p;
        p = Pop( A );
        q = Pop( B );
    }

    if((isEmpty( A ) || isEmpty( B )) && p == q){
        ans = p;
    }

    return ans;
}

方法三：前后双指针（本题最优解）

先算出2个链表的长度，长的链表的指针先多走几步，确保剩下的长度和另一个相等，然后2个指针同时后移，判断是否指向同一个结点；

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
  
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    struct ListNode *p,*q;
    int La,Lb;
    La = Lb = 0;

    for(p=headA;p;p=p->next,La++);
    for(q=headB;q;q=q->next,Lb++);

    p = headA;
    q = headB;
    int K;

    if(La >= Lb){
        K = La -Lb;
        while(K--){
            p = p->next;
        }
    }else{
        K = Lb - La;
        while(K--){
            q = q->next;
        }
    }

    while(p){
        if(p == q){
            break;
        }else{
            p = p->next;
            q = q->next;
        }
    }

    return p;
}

大神的NB双指针：

考虑构建两个节点指针 A​ , B 分别指向两链表头节点 headA , headB ，做如下操作：

• 指针 A 先遍历完链表 headA ，再开始遍历链表 headB ，当走到 node 时，共走步数为：
  a + (b - c)
• 指针 B 先遍历完链表 headB ，再开始遍历链表 headA ，当走到 node 时，共走步数为：
  b + (a - c)

如下式所示，此时指针 A , B 重合，并有两种情况：

a + (b - c) = b + (a - c)

• 若两链表 有 公共尾部 (即 c > 0c>0 ) ：指针 A , B 同时指向「第一个公共节点」node 。
• 若两链表 无 公共尾部 (即 c = 0c=0 ) ：指针 A , B 同时指向 nullnull 。
  因此返回 A 即可。

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    struct ListNode *A,*B;
    A = headA;
    B = headB;

    while(A != B){
        A = A==NULL ? headB : A->next;
        B = B==NULL ? headA : B->next;
    }
    
    return A;
}

这代码太优美了_{！！！大神NB}！！