[链表]BM10 两个链表的第一个公共结点-简单

​​BM10 两个链表的第一个公共结点​​

知识点​​链表​​

描述

输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

数据范围： $n \le 1000$

要求：空间复杂度 $O(1)$，时间复杂度 $O(n)$

例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：

可以看到它们的第一个公共结点的结点值为6，所以返回结点值为6的结点。

输入描述：

输入分为是3段，第一段是第一个链表的非公共部分，第二段是第二个链表的非公共部分，第三段是第一个链表和第二个链表的公共部分。 后台会将这3个参数组装为两个链表，并将这两个链表对应的头节点传入到函数FindFirstCommonNode里面，用户得到的输入只有pHead1和pHead2。

返回值描述：

返回传入的pHead1和pHead2的第一个公共结点，后台会打印以该节点为头节点的链表。

示例1

输入：

{1,2,3},{4,5},{6,7}

复制返回值：

{6,7}

复制说明：

第一个参数{1,2,3}代表是第一个链表非公共部分，第二个参数{4,5}代表是第二个链表非公共部分，最后的{6,7}表示的是2个链表的公共部分
这3个参数最后在后台会组装成为2个两个无环的单链表，且是有公共节点的

示例2

输入：

{1},{2,3},{}

复制返回值：

{}

复制说明：

2个链表没有公共节点 ,返回null，后台打印{}

题解

方法一

借助于set遍历链表

#include <bits/stdc++.h>

struct ListNode
{
  int val;
  struct ListNode *next;
  ListNode(int x) : val(x), next(nullptr)
  {
  }
  ListNode() = default;
};

ListNode *FindFirstCommonNode(ListNode *pHead1, ListNode *pHead2)
{
  std::unordered_set<ListNode *> s;
  while (pHead1 != nullptr)
  {
    s.insert(pHead1);
    pHead1 = pHead1->next;
  }

  while (pHead2 != nullptr)
  {
    if (s.find(pHead2) != s.end())
    {
      return pHead2;
    }
    pHead2 = pHead2->next;
  }
  return nullptr;
}

方法二

先分别计算2个链表的长度，假设长度分别为n,m，让比较长的链表先走|n - m|，然后再同步走，当两个链表指向同一节点的时候就是我们要找的节点了。

int ListLenth( ListNode* pHead){  //计算链表长度的函数
    ListNode* p = pHead;
    int n = 0;
    while(p != NULL){
        n++;
        p = p->next;
    }
    return n;
}
ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
    int p1 = ListLenth(pHead1); 
    int p2 = ListLenth(pHead2);
    if(p1 >= p2){            //当链表1更长时，链表1指针先走p1-p2步
        int n = p1 - p2;
        for(int i = 0; i < n; i++){
            pHead1 = pHead1->next;
        }
        while((pHead1 != NULL) && (pHead2 != NULL) && (pHead1 != pHead2)){ //两个链表同时移动，直到有公共结点时停下
            pHead1 = pHead1->next;
            pHead2 = pHead2->next;
        }
    }
    else{      //反之，则链表2先行p2-p1步
        int n = p2 - p1;
        for(int i = 0; i < n; i++){
            pHead2 = pHead2->next;
        }
        while((pHead1 != NULL) && (pHead2 != NULL) && (pHead1 != pHead2)){
            pHead1 = pHead1->next;
            pHead2 = pHead2->next;
        }
    }
    return pHead1;
}

方法三

由上种方法长度差的思路，不同上述一个指针先走另一个指针后走，仅需将两个链表连在一起，两个指针同步走。易知将两个链表连在一起长度都相等，对于遍历两个链表的两个指针，公共部分走的步数是一样的，非公共部分因都走了两个链表，因此也是相同的，所以绕了一圈，第一个相同的结点便是第一个公共结点。

也不需要物理上将两个链表连在一起，仅需指针在一个链表的尾部时直接跳到另一个链表的头部。具体示例可参考图解。 

ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) 
{
    if(!pHead1 || !pHead2)  //其中有一个为空，则不能有公共结点，返回null
        return NULL;
    ListNode* p1 = pHead1;
    ListNode* p2 = pHead2;
    while(p1 != p2)  //相当于遍历两个链表的所有值
    {
        p1 = p1 == NULL ? pHead2 : p1->next;  
        p2 = p2 == NULL ? pHead1 : p2->next;
    }
    return p1;
}