【环形链表】_闭环链表-CSDN博客

本文链接：https://blog.csdn.net/langk_/article/details/123609770

1.输入两个链表，找出它们的第一个公共结点。OJ链接
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 nulllt

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

在这里插入图片描述
题目数据保证整个链式结构中不存在环。
注意，函数返回结果后，链表必须保持其原始结构 。
思路一
A链表中的每个节点跟B链表中的节点依次进行比较，如果有相等，就是相交，第一个相等的节点就是交点。

时间复杂度为O(m*n)

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
{
    struct ListNode *tailA = headA,*tailB = headB;
    while(tailA != NULL)
    {
        tailB = headB;
        while(tailB != NULL)
        {
            if(tailA == tailB)
            {
                return tailA;
            }
            tailB = tailB->next;
        }
        tailA = tailA->next;
    }
    return NULL;  
}

思路二
A链表找到尾节点，B链表找到尾节点，如果尾节点相等，就是相交。然后求出两个链表的长度(lenA,lenB),长的链表先走 |lenA-lenB| ¹步，再一起走，第一地址² 相等的节点就是交点。

时间复杂度为O(m+n).

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
{
    struct ListNode *tailA = headA,*tailB = headB;
    int lenA = 1,lenB = 1;
    //求尾节点和链表长度
    while(tailA->next != NULL)
    {
        tailA = tailA->next;
        lenA++;
    }
    while(tailB->next != NULL)
    {
        tailB = tailB->next;
        lenB++;
    }
    //判断是否相交
    if(tailA != tailB)
    {
        return NULL;
    }
    //相交求交点
    struct ListNode *longlist = headA,*shortlist = headB;
    if(lenA < lenB)
    {
        longlist = headB;
        shortlist = headA;
    }
    int k = abs(lenA - lenB);
    //长的链表先走k步
    while(k--)
    {
        longlist = longlist->next;
    }
    //然后一起走，第一个地址相等的节点就交点
    while(longlist && shortlist)
    {
        if(longlist == shortlist)
        {
            return longlist;
        }
        longlist = longlist->next;
        shortlist = shortlist->next;
    }
    return NULL;
}

2.给定一个链表，判断链表中是否有环。 OJ链接

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1：

在这里插入图片描述

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
思路
快慢指针，两个指针一起开始走，一个走的快，一个走得慢，如果有环，当慢的进入环，快的一定已经进入环内，然后快的开始追逐慢的，当快的和慢的相等，则说明有环。

bool hasCycle(struct ListNode *head) {
    struct ListNode *slow = head,*fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(fast == slow)
        {
            return true;
        }
    }
    return false;
}

扩展问题
a).slow一次走一步，fast一次走两步一定能追上吗？请证明。
b).slow一次走一步，fast一次走三步，一次走四步呢？
c).请求出环链表的入口节点。
3.给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 NULL OJ链接
在这里插入图片描述
a).假设fast与slow相距N，环长为C，他两的相对位移为1。设需要X次追上，则1*X=N,X=N(整数)。所以一定可以追上。
b).假设fast与slow相距N，环长为C，fast一次走三步，他两的相对位移为2。设需要X次追上，则2X=N,X=N/2(当N为偶数时，X为整数)。当N为奇数时，一定会和slow错过，且fast比slow快一步，这时fast与slow相距C-1步 ³，此时如果C-1为偶数，就可以追上，否则到最后fast还会与slow错过一步⁴，还是相距C-1步，永远追不上。
fast走四步照上分析。
c).
思路一

在这里插入图片描述

在这里插入图片描述
当slow走L+X步时，fast走L+ NC+X步，并且fast走的是slow的一倍，所以
2（X+L）= L+NC+X，L+X=NC,L=NC-X,L= (N-1)C+(C-X),所以head，meet同时开始走，一定会在环链表入口节点相遇。

struct ListNode *detectCycle(struct ListNode *head) 
{
  struct ListNode *slow = head,*fast = head;
  while(fast && fast->next)
  {
  //慢指针一次走一步
  //快指针一次走两步
      slow  =slow->next;
      fast = fast->next->next;
      //判断是否有环
      if(slow == fast)
      {
          struct ListNode* meet = slow;
          //找环链表入口节点
          while(meet != head)
          {
              meet = meet->next;
              head = head->next;
          }
          return meet;
      }
  }
return NULL;
}

思路二
把meet打开，把它转化为求相交链表问题
在这里插入图片描述

注脚的解释：||为绝对值 ↩︎
注脚的解释：两个节点是不是交点比较的是地址，而不是值。比如：假设a1->val = 2,b1->val = 2,但是不是交点。 ↩︎
间距缩小fast追slow过程（N -> N-2 -> N-4 -> … -> 5 -> 3 -> 1 -> -1），此时环长度为C，fast在slow前一步，所以相距为C-1。 ↩︎ ↩︎
另N=C- 1 ³ ↩︎