LeetCode --- 链表相关oj题 -- 3

言_初

已于 2023-01-06 21:19:17 修改

阅读量198

点赞数 1

文章标签：链表 leetcode 算法

于 2022-08-25 22:44:43 首次发布

本文链接：https://blog.csdn.net/m0_71722065/article/details/126511563

版权

一：环形链表（141）

给你一个链表的头节点 head ，判断链表中是否有环。

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

如果链表中存在环，则返回 true 。否则，返回 false 。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
链接：https://leetcode.cn/problems/linked-list-cycle

思路：

    //判断链表是否有环

    //定义2个指针，快慢指针（fast一次走一步，slow一次走两步）

    //最后如果fast为空了，那么链表就是不带环的，就返回false

    //如果最后fast等于slow了，那么就证明该链表是有环的，就返回true

bool hasCycle(struct ListNode *head)
{
    //判断链表是否有环
    //定义2个指针，快慢指针
    //最后如果fast为空了，那么链表就是不带环的，就返回false
    //如果最后fast等于slow了，那么就证明该链表是有环的，就返回true
    struct ListNode* slow=head;
    struct ListNode* fast=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)
        {
            return true;
        }
    }
    return false;
}

思考关于链表带环问题的2个拓展问题：

第一个问题：

问题：当slow一次走一步，fast一次走两步的时候，如果链表带环的话，为什么这2个指针就一定会在环里面相遇呢？有没有可能会错过，永远遇不到呢？

解答： slow一次走一步，fast一次走两步的这种情况，如果链表带环，那么fast和slow就一定会在环里面相遇的。

第二个问题：

问题：如果链表带环，既然slow一次走一步，fast一次走二步，fast和slow一定会在环里面相遇，那么如果是slow一次走一步，但是fast一次走n步（n>2），那么是否还一定会在环里面相遇呢？

解答：当链表带环，slow一次走一步，但是fast一次走n步（n>2），的时候，fast和slow就不一定会在环里面相遇了。

（下面演示了一下当n等于3的情况，当n等于4、5、6....，等的情况推导方式就都是类似的）

二：环形链表 II（142）

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

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

不允许修改链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。
链接：https://leetcode.cn/problems/linked-list-cycle-ii

思路1：

首先定义快慢指针，fast和slow

第一步要先找到该环形链表中slow和fast相遇的那个位置meetnode

然后再定义2个指针，一个指针从快慢指针的相遇点开始走，另一个指针从链表头开始走，它们会在环的入口点处相遇。（公式法）

struct ListNode *detectCycle(struct ListNode *head) 
{
    //第一步要先找到该环形链表中slow和fast相遇的那个位置meetnode
    struct ListNode* slow=head;
    struct ListNode* fast=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(slow==fast)
        {
            struct ListNode*meetnode=slow;
            struct ListNode* cur1=head;
            struct ListNode* cur2=meetnode;
            while(cur1!=cur2)
            {
                cur1=cur1->next;
                cur2=cur2->next;
            }
            return cur1;
        }
    }
    return NULL;
    //然后，定义一个指针从原链表头结点开始走
    //在定义一个指针，从meetnode的位置开始走
    //由公式法可知，当新定义的这2个指针相遇的位置即为我们所求的位置
}

思路2：

使用到链表相交的知识点

首先定义快慢指针，fast和slow

第一步要先找到该环形链表中slow和fast相遇的那个位置meetnode

然后把原链表当成是2个新的链表：一个从原链表的头开始走，另一个从我们找到的那个相遇点的next开始走，然后看它们的交点（链表相交），就是我们的所求结点。

struct ListNode *detectCycle(struct ListNode *head) 
{
    //使用快慢指针，找到fast和slow相遇的那个结点 meetnode
    struct ListNode* slow=head;
    struct ListNode* fast=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)
        {
            struct ListNode* meetnode=fast;

            //相交的第一个结点
            //走到这里一定是有交点的
            struct ListNode* cur1=head;
            int size1=1;
            while(cur1->next!=meetnode->next)
            {
                size1++;
                cur1=cur1->next;
            }
            struct ListNode* cur2=meetnode->next;
            int size2=1;
            while(cur2->next!=meetnode->next)
            {
                size2++;
                cur2=cur2->next;
            }
            int gap=abs(size1-size2);
            struct ListNode* shortlist=head;
            struct ListNode* longlist=meetnode->next;
            if(size1>size2)
            {
                longlist=head;
                shortlist=meetnode->next;
            }
            while(gap--)
            {
                longlist=longlist->next;
            }
            while(shortlist!=longlist)
            {
                shortlist=shortlist->next;
                longlist=longlist->next;
            }
            return longlist;
        }
    }
    //使用链表相交的知识来求解入环的第一个结点
    return NULL;
}

三：复制带随机指针的链表（138）

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的深拷贝。深拷贝应该正好由 n 个全新节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。
你的代码只接受原链表的头节点 head 作为传入参数。

示例 1：

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
示例 2：

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]
示例 3：

输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

链接：https://leetcode.cn/problems/copy-list-with-random-pointer

思路：

1.先复制结点，插入到原结点和下一个结点之间

2.根据原结点的random，处理复制结点的random

3.复制结点解下来，链接成一个新的链表，并恢复原链表的链接关系

struct Node* copyRandomList(struct Node* head)
{
    //1.复制结点，插入到原结点和下一个结点之间
	struct Node* cur=head;
    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处理复制结点的random
    // 要是原结点的random是NULL，那么复制结点的random也是NULL
    // 当原结点的random不是NULL的时候，那么复制结点的random就是原结点random的next
    cur=head;
    while(cur)
    {
        struct Node* copy=cur->next;
        struct Node* next=copy->next;
        if(cur->random==NULL)
        {
            copy->random=NULL;
        }
        else
        {
            copy->random=cur->random->next;
        }
        cur=next;
    }

    //3.将复制结点解下来，链接成为新的链表
    // 并恢复原链表的链接关系
    struct Node* newhead=NULL;
    struct Node* tail=NULL;
    cur=head;
    while(cur)
    {
        struct Node* copy=cur->next;
        struct Node* next=copy->next;
        if(tail==NULL)
        {
            newhead=copy;
            tail=copy;
        }
        else
        {
            tail->next=copy;
            tail=copy;
        }
        cur->next=next;
        cur=next;
    }
    //返回新链表的头
    return newhead;
}