力扣（LeetCode）160. 相交链表

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

如下面的两个链表：

在节点 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。

思路：用map标记即可
膜一波大佬，思路清晰到让我五体投地（我啥时候才能那么强）
https://leetcode-cn.com/problems/intersection-of-two-linked-lists/comments/3107

#include<iostream>
#include<cstdlib>
#include<map>
using namespace std;

typedef struct ListNode
{
    int val;
    ListNode *next;
} ListNode,*PtrToNode;

void Print(PtrToNode N)
{
    PtrToNode p = N;
    while(p!=NULL)
    {
        printf("%d ",p->val);
        p = p->next;
    }
    printf("\n");
    return;
}

PtrToNode Insert(PtrToNode N,int e)
{
    PtrToNode p = (PtrToNode)malloc(sizeof(ListNode));
    p->val = e;
    p->next = NULL;
    if(N == NULL)
    {
        N = p;
    }
    else
    {
        PtrToNode q = N;
        while(q->next != NULL)
        {
            q = q->next;
        }
        q->next = p;
    }
    return N;
}

class Solution
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
    {
        if(headA==NULL || headB==NULL)
            return NULL;

        int lenA = 0,lenB = 0;
        ListNode *A = headA,*B = headB;
        map<ListNode*,int>M;
        while(A!=NULL)
        {
            lenA++;
            A = A->next;
        }
        while(B!=NULL)
        {
            lenB++;
            B = B->next;
        }

        A = headA;
        B = headB;

        if(lenA>=lenB)
        {
            while(lenA!=lenB)
            {
                A = A->next;
                lenA--;
            }
        }
        else
        {
            while(lenA!=lenB)
            {
                B = B->next;
                lenB--;
            }
        }

        while(lenA!=0)
        {
            M[A]++;
            M[B]++;

            if(M[A]>1)
                return A;

            A = A->next;
            B = B->next;

            lenA--;
        }

        return NULL;
    }
};

//class Solution
//{
//public:
//    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
//    {
//        /*
//        定义两个指针, 第一轮让两个到达末尾的节点指向另一个链表的头部,
//        最后如果相遇则为交点(在第一轮移动中恰好抹除了长度差)
//        两个指针等于移动了相同的距离, 有交点就返回, 无交点就是各走了两条指针的长度
//        */
//        if(headA == NULL || headB == NULL)
//            return NULL;
//        ListNode *pA = headA, *pB = headB;
//        /* 在这里第一轮体现在pA和pB第一次到达尾部会移向另一链表的表头,
//         而第二轮体现在如果pA或pB相交就返回交点,
//          不相交最后就是null==null */
//        while(pA != pB)
//        {
//            pA = pA == NULL ? headB : pA->next;
//            pB = pB == NULL ? headA : pB->next;
//        }
//        return pA;
//    }
//};

int main()
{
    Solution s;
    PtrToNode N,M,P,temp;
    N = NULL;
    M = NULL;
    P = NULL;
    N = Insert(N,4);
    N = Insert(N,1);
//    N = Insert(N,8);
//    N = Insert(N,4);
//    N = Insert(N,5);
    M = Insert(M,5);
    M = Insert(M,0);
    M = Insert(M,1);
    P = Insert(P,8);
    P = Insert(P,4);
    P = Insert(P,5);

    PtrToNode p = N,q = M;
    while(p->next!=NULL)
    {
        p = p->next;
    }
    p->next = P;

    while(q->next!=NULL)
    {
        q = q->next;
    }
    q->next = P;
    Print(N);
    Print(M);
    Print(P);

    temp = s.getIntersectionNode(N,M);
//    Print(temp);
    printf("%d\n",temp->val);

    return 0;
}