fast指针和slow指针错过还能再相遇吗

阿博历练记

已于 2023-05-14 08:42:36 修改

阅读量181

点赞数 35

分类专栏：数据结构与算法数据结构刷题练习文章标签：链表算法数据结构

于 2023-05-13 23:53:09 首次发布

本文链接：https://blog.csdn.net/qq_65662221/article/details/130654520

版权

数据结构与算法同时被 2 个专栏收录

13 篇文章 2 订阅

订阅专栏

数据结构刷题练习

7 篇文章 2 订阅

订阅专栏

文章详细探讨了如何使用快慢指针检测链表中是否存在环，以及在环中找到入口点的问题。同时，还介绍了复制带有随机指针的链表的算法，包括节点拷贝、random指针拷贝和恢复原链表的步骤。

摘要由CSDN通过智能技术生成

🍉博客主页：阿博历练记
📖文章专栏：数据结构与算法
🚍代码仓库：阿博编程日记
🌹欢迎关注：欢迎友友们点赞收藏+关注哦

在这里插入图片描述

文章目录

🖋1.题目描述

在这里插入图片描述

💡逻辑分析

在这里插入图片描述

⭐疑问解析&&思维拓展

📋1.fast和slow一定会相遇吗？

在这里插入图片描述

📋2.slow一次走1步，fast一次走3步，一定会相遇吗？

在这里插入图片描述

⛳⛳友友们注意，这种情况fast和slow不一定相遇，但是slow一次走两步，fast一次走三步，它们一定会相遇，只要保证它们之间的步数差为1就一定会相遇.

🔍代码展示

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

在这里插入图片描述

🖋2.题目描述

在这里插入图片描述

💡逻辑分析

友友们，这里有个经典的结论📑：一个指针从环中的相遇点走，一个指针从链表头开始走，最终它们会在环的入口点处相遇.

在这里插入图片描述

🔍代码展示

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(head!=meet)
        {
            head=head->next;
            meet=meet->next;
        }
        return  head;
    }
  }
    return  NULL;
}

⭐思维拓展

在这里插入图片描述

🔍代码展示

struct ListNode *detectCycle(struct ListNode *head) {
    struct  ListNode*slow=head,*fast=head,*tailh=head;
    struct  ListNode*meet=NULL,*meetNext=NULL;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)
        {
           meet=slow;
           meetNext=meet->next;
           meet->next=NULL;
           struct  ListNode*tailN=meetNext;
           int lenN=0,lenh=0;
           while(tailh)
           {
            tailh=tailh->next;
             lenh++;
           }
            while(tailN)
           {
           tailN=tailN->next;
           lenN++;
           }
           int gap=abs(lenN-lenh);
           struct  ListNode*longlist=meetNext;
           struct  ListNode*shortlist=head;
           if(lenN<lenh)
          {
           longlist=head;
           shortlist=meetNext;
          }
           while(gap--)
          {
           longlist=longlist->next;
          }
          while(longlist!=shortlist)
          {
          longlist=longlist->next;
          shortlist=shortlist->next;
          }
          return  longlist;
     }
  }
return  NULL;
}

🖋3.题目描述

在这里插入图片描述

💡逻辑分析

在这里插入图片描述

🔍代码展示

struct Node* copyRandomList(struct Node* head) {
   //  1.拷贝原链表结点
   struct  Node*cur=head;
   struct  Node*copyhead=NULL;
   struct  Node*copytail=NULL;
   while(cur)
   {
       struct  Node*copy=(struct Node*)malloc(sizeof(struct Node));
       copy->val=cur->val;
       struct  Node*next=cur->next;
       cur->next=copy;
       copy->next=next;
       cur=next;
   }
   //2.拷贝random
   cur=head;
   while(cur)
   {
   struct  Node*copy=cur->next;
   if(cur->random==NULL)
   {
       copy->random=NULL;
   }
   else
   {
       copy->random=cur->random->next;
   }
   cur=cur->next->next;
   }
   //3.恢复原链表，组合新链表
   cur=head;
   while(cur)
   {
   struct  Node*copy=cur->next;
    if(copytail==NULL)
     {
     copyhead=copytail=copy;
     }
     else
    {
       copytail->next=copy;
       copytail=copytail->next;
    }
    cur->next=copy->next;
    cur=copy->next;
   }
   return  copyhead;
}