160. 相交链表

leetcode热题100 160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

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

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

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

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 3:

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：No intersection
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

题目解析

实际上整个题目相对简单，让我们找到相交的节点，意思就是两个链表存在相交的节点就返回相交节点的地址值，否则返回空。

//链表结构体如何下
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}// 构造函数
};

方法 1 暴力破解，所有情况都便利，相当于两层循环

思路

暴力破解的思路很简单，就是每种情况都遍历一次，这种情况只是比较耗时，但也是一种解决方案。

按照这样一个思路，首先A的a1，然后依次遍历B的
a1与下面的匹配
b1，b2，b3，c1，c2，c3
a2与下面的匹配，
b1，b2，b3，c1，c2，c3
c1与下面的匹配，
b1，b2，b3，c1，
在c1出匹配成果，所以得到结果在c1处

具体代码如下：

    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        //暴力破解，所有情况都便利，相当于两层循环遍历所有的情况
        ListNode* pa;
        ListNode* pb;
        pa = headA;
        while (pa != nullptr)
        {
            pb = headB;
            while (pb != nullptr)
            {
                if (pa == pb)
                {
                    return pa;
                }
                pb = pb->next;
            }
            pa = pa->next;
        }
        return nullptr;
    }

方法 2 哈希表

思路

这个题目为什么会想到哈希表呢？因为哈希表的特性，是集合，集合中不能存在相同的元素，因为我们将A链表地址值存入哈希表中，遍历B链表的时候，如果存在地址值一样的节点，那么在第一个相同元素的地方，就是相交的节点，那么就能很容易的找出地址值相同的节点，即相交的节点。

具体代码实现如下：

unordered_set<ListNode*> setA;  #定义哈希表的一种方式,并且将ListNode结构体的的地址作为哈希表的元素类型
setA.insert(pa);//往哈希表中插入元素
setA.count(pb); //哈希表中是否存在pb这个值，如果存在返回1，如果不存在返回0

    ListNode* getIntersectionNode2(ListNode* headA, ListNode* headB) {
        //哈希集合，这里需要首先会使用简单的哈希
        unordered_set<ListNode*> setA;
        ListNode* pa;
        ListNode* pb;
        pa = headA;
        pb = headB;
        while (pa != nullptr)//
        {
            setA.insert(pa);
            pa = pa->next;
        }
        while (pb != nullptr)
        {
            if (setA.count(pb))//如果在哈希表中查找到存在与B链表地址一样的值，则直接返回当前值的地址，否则继续循环链表B
            {
                return pb;
            }
            pb = pb->next;
        }
        return nullptr; //最后找不到的时候，就证明没有相交的节点，直接返回nullptr即可
    }

方法 3 双指针

思路

实际上我最开始的适合想到的也是双指针，但是由于思维不足所以没有想到这么巧妙的方法。

我们这样思考，双指针肯定就是A链表一个，B链表一个，这样才能比较，才能完成题目，但是又不能像循环一样，这么才能做到走到相同的位置上呢？就是一个巧妙地数学方案，我们设置A的单独部分为a，B链的单独部分为b，共同部分就为c。
在这样的基础上，我们能想到，双指针往后走，怎么才能到达同一个点呢？就是指针相遇，
A走完就是=a+c
B走完就是=b+c
相遇是什么情况？？？那很明显a+c+b=b+c+a，我们只要执行到最后，换条路走，那么我们就可以找到相交点。

接下里我们思考不相遇的情况，

那同样的道理，

具体代码实现如下：a+b=b+a,刚好走到最后一个位置null，可以直接返回。
但是这个前提是我们需要判断最开始的状态，看两个链表是不是存在null的情况，这样这个程序才能完成

ListNode* getIntersectionNode3(ListNode* headA, ListNode* headB) {
    //双指针，主要是数学问题，假设相交的部分为c，a为不相交的部分，b为不相交的部分
    // a+c  ..   b+c
    //要这两个相等 那就第一个再走一遍b，第二个再走一遍a
    //a+c+b = b+c+a,这样就能到达相交的部分(这是相交的情况)

    // 不相交 的时候，同样a+b+c之后就指向同一个null,同样可以获得争取答案
    ListNode* p1;
    ListNode* p2;
    p1 = headA;
    p2 = headB;
    if (p1 == nullptr || p2 == nullptr)
    {
        return nullptr;
    }
    while (p1 = p2)
    {
        if (p1 == nullptr)
        {
            p1 = headB;
        }
        else
        {
            p1 = p1->next;
        }
        if (p2 == nullptr)
        {
            p2 = headA;
        }
        else {
            p2 = p2->next;
        }
    }
    return p1;
}

自己的代码思路，谢谢，如果有问题，希望各位网友提出，有意见我看到了一定回复