3.2较难的链表OJ

本篇博客来解析三道较有难度的链表OJ题，题目均已插入超链接，点击即可跳转~

一、带环链表

1、题目描述

给你一个链表的头节点 head ，判断链表中是否有环。如果链表中存在环 ，则返回 true 。 否则，返回 false 。

2、题目分析

思路：快慢指针，fast的速度为slow的2倍，slow进环之后，fast开始追slow，如果能追上就是带环链表

具体代码实现如下：

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

二、寻找入环的第一个节点

1、题目描述

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null，不允许修改链表

2、思路分析

（1）思路一：快慢指针

当slow和fast相遇时（记作meet），分别分析fast和slow走过的路程，再由fast路程是slow的2倍，可列出等式2*（L+N）=L+x*C+N，整理过后分析出结论：一个指针从head开始走，一个指针从meet开始走，必在入环处相遇
具体代码实现如下

struct ListNode *detectCycle(struct ListNode *head) 
{
    struct ListNode*fast=head;
    struct ListNode*slow=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)//此时fast和slow指向同一个位置，记作meet
        {
            struct ListNode*meet=fast;
            while(head!=meet)
            {
                head=head->next;
                meet=meet->next;
            }
            return head;
        }
    }
    return NULL;
}

（2）思路二：转化为链表相交问题

//核心操作
newhead=meet->next;
meet->next=NULL;

此处代码实现与3.1中的相交链表逻辑一致，不再赘述，读者可自行实现

三、随机链表的复制

1、题目描述

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

简单来说就是：拷贝出一个值和指针指向和当前链表一模一样的链表

2、题目分析

• 第一步：拷贝节点插入在原节点后面（让拷贝节点和原节点建立一个关联关系）
  

//1.拷贝节点插入在原节点后面（拷贝节点和原节点建立了一个关联关系）
    Node*cur=head;
    while(cur)
    {
        Node*copy=(Node*)malloc(sizeof(Node));
        copy->val=cur->val;//22-24行完成：在cur之后完成cur指向节点的拷贝（random除外）
        copy->next=cur->next;
        cur->next=copy;

        cur= copy->next;//cur往后走
    }

• 第二步：控制random指针
  

分成两种情况：一种是原节点的random为NULL，那么拷贝节点的random也要为NULL；一种是要找到原节点的random，再对拷贝节点的random进行操作
代码如下

//2.控制random
    cur=head;
    while(cur)
    {
        Node*copy=cur->next;
        if(cur->random==NULL)
        {
            copy->random=NULL;
        }
        else
        {
            copy->random=cur->random->next;
        }
        cur=copy->next;
    }

• 第三步：把所有拷贝的节点摘取下来，依次尾插到新链表中

代码实现如下

  //3.把所有的copy拿下来组成一个新链表
    Node*copyhead=NULL;
    Node*copytail=NULL;
    cur=head;
    while(cur)
    {
        Node*copy=cur->next;
        Node*next=copy->next;
        if(copytail==NULL)
        {
            copytail=copy;
            copyhead=copy;
        }
        else
        {
            copytail->next=copy;
            copytail=copytail->next;
        }
        cur=next;
    }

本题完整代码呈现

typedef struct Node Node;
struct Node* copyRandomList(struct Node* head)
{
	//1.拷贝节点插入在原节点后面（拷贝节点和原节点建立了一个关联关系）
    Node*cur=head;
    while(cur)
    {
        Node*copy=(Node*)malloc(sizeof(Node));
        copy->val=cur->val;//22-24行完成：在cur之后完成cur指向节点的拷贝（random除外）
        copy->next=cur->next;
        cur->next=copy;

        cur= copy->next;//cur往后走
    }


    //2.控制random
    cur=head;
    while(cur)
    {
        Node*copy=cur->next;
        if(cur->random==NULL)
        {
            copy->random=NULL;
        }
        else
        {
            copy->random=cur->random->next;
        }
        cur=copy->next;
    }

    //3.把所有的copy拿下来组成一个新链表
    Node*copyhead=NULL;
    Node*copytail=NULL;
    cur=head;
    while(cur)
    {
        Node*copy=cur->next;
        Node*next=copy->next;
        if(copytail==NULL)
        {
            copytail=copy;
            copyhead=copy;
        }
        else
        {
            copytail->next=copy;
            copytail=copytail->next;
        }
        cur=next;
    }
    return copyhead;
}