【数据结构与算法】---OJ链表题来源力扣和牛客

最新推荐文章于 2023-01-15 23:24:17 发布

旧梦拾遗186

最新推荐文章于 2023-01-15 23:24:17 发布

阅读量382

点赞数 10

分类专栏：数据结构成长日记文章标签：链表 leetcode 数据结构算法 c语言

本文链接：https://blog.csdn.net/weixin_67900732/article/details/126220720

版权

链表环形链表快慢指针复制链表随机指针

关键词由CSDN通过智能技术生成

数据结构成长日记专栏收录该内容

17 篇文章 1 订阅

订阅专栏

作者：旧梦拾遗186

专栏：数据结构成长日记

环形链表

环形链表https://leetcode.cn/problems/linked-list-cycle/

给你一个链表的头节点 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
解释：链表中没有环。

提示：

链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个有效索引。

进阶：你能用 O(1)（即，常量）内存解决此问题吗？

题解：

思路：带环链表不能遍历。。。我们可以用快慢指针来解决这道题目,快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表其实位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾：
bool hasCycle(struct ListNode *head) {
    struct ListNode* slow=head;
    struct ListNode* fast=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
         if(slow==fast)
    {
        return true;

    }
   
    }
   return false;
    
}

环形链表扩展问题：

【扩展问题】

为什么快指针每次走两步，慢指针走一步可以？

假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚

进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。

此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情

况，因此：在满指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。

快指针一次走 3 步，走 4 步， ...n 步行吗？

为什么快指针每次走两步，慢指针走一步可以追上，会不会错过？

slow一次走一步，fast一次走三步呢

slow一次走一步，fast一次走X步呢

环形链表II

给定一个链表的头节点 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
解释：链表中没有环。

提示：

链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引

进阶：你是否可以使用 O(1) 空间解决此题？

题解：

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 meet;
        }
    }
    return NULL;
}

思路二：转化成相交链表，从相遇点断开后，作为一个链表，另一个链表从头开始，链表开始入环的第一个节点就相当于这两个链表的交点，而找链表的交点就是上面的题目相交链表。

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
 {
     struct ListNode*curA = headA,*curB = headB;
     int LenA = 0,LenB = 0;
     while(curA)
     {
         curA = curA->next;
         LenA++;
     } 
     while(curB)
     {
         curB = curB->next;
         LenB++;
     }
     if(curA != curB)
     {
         retur NULL;
     }
     struct ListNode*longlist = headA,*shortlist = headB;
     if(LenA<LenB)
     {
         longlist = headB;
         shortlist = headA;
     }
     int gap = abs(LenA-LenB);
     while(gap--)
     {
         longlist = longlist->next;
     }
     while(longlist!=shortlist)
     {
         longlist = longlist->next;
         shortlist = shortlist->next;
     }
     return longlist;
 }
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;
            struct ListNode*next = meet->next;
            //断开
            meet->next = NULL;
           struct ListNode*enterNode = getIntersectionNode(head,next);
           //恢复原来的链表
           meet->next = next;
           return enterNode;
        }
    }
    return NULL;
}

复制带随机指针的链表

复制带随机指针的链表https://leetcode.cn/problems/copy-list-with-random-pointer/

给你一个长度为 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]]

提示：

0 <= n <= 1000
-104 <= Node.val <= 104
Node.random 为 null 或指向链表中的节点。

题解：

本题较难。如果我们每个节点都去进行复制，这道题的random我们较难去处理：

struct Node* copyRandomList(struct Node* head) {
    //copy节点
	struct Node* cur = head;
    struct Node*copy = NULL;
    struct Node*next = NULL;
    while(cur)
    {
        //赋值链接
        next = cur->next;
        copy = (struct Node*)malloc(sizeof(struct Node));
        copy->val = cur->val;

        cur->next = copy;
        copy->next = next;
        //迭代
        cur = next;
    }
    
    //更新copy的random
    cur = head;
    while(cur)
    {
        copy = cur->next;
        if(cur->random == NULL)
        {
            copy->random = NULL;
        }
        else
        {
            copy->random = cur->random->next;
        }
        //迭代
        cur = cur->next->next;
    }
    //copy节点解下来链接在一起，恢复原链表
    struct Node*copyHead = NULL,*copyTail = NULL;
    cur = head;
    while(cur)
    {
        copy = cur->next;
        next = copy->next;

        //取节点尾插
        if(copyTail == NULL)
        {
            copyHead = copyTail = copy;
        }
        else
        {
            copyTail->next = copy;
            copyTail = copyTail->next;
        }
        //恢复原链表
        cur->next = next;

        cur = next;
    }
    return copyHead;
}