顺序表链表OJ题(3)——【数据结构】

这篇具有很好参考价值的文章主要介绍了顺序表链表OJ题(3)——【数据结构】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

W...Y的主页 😊

代码仓库分享 💕


前言:

 今天是链表顺序表OJ练习题最后一次分享,每一次的分享题目的难度也再有所提高,但是我相信大家都是非常机智的,希望看到博主文章能学到东西的可以一键三连关注一下博主。

话不多说,我们来看今天的OJ习题.。

【leetcode 142.环形链表II】

OJ链接

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

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

不允许修改 链表。

示例 1:

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

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

示例 2:

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

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

示例 3:

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

输入:head = [1], pos = -1
输出:返回 null
解释:链表中没有环。

题目函数接口:

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

head:目标链表


分析:在上一篇博客中,我们讲述了如何寻找相遇点,创建两个指针slow与fast,fast的速度为slow的两倍,最终会在环中追及到。

下面讲述的方法与昨天的有关联:顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法 

slow进入环后只会走不到一圈就会被fast追上,如果L足够长,环足够小fast会在环中走n圈(n>=1)。

我们分析完,题目就会迎刃而解。我们只需要先找到相遇点,然后一个指针从起点走,一个指针从相遇点走,它们相遇后的地址就是我们要的答案!!!

代码演示:

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 )
        {
          struct ListNode *cur = head;
            while(cur != slow)
            {
                cur = cur->next;
                slow = slow->next;
            }
            return slow;
        }
    }
    return NULL;
}

 再给大家提供一种思路!!!

思路二:我们可以先找到相遇点,然后将环从相遇点截断,这个链表就变成了相交链表,然后找到相交链表的相交点即可。

这个想法很简便也很大胆,不知道相交链表已经做题方法的可以在顺序表链表OJ题(2)->【数据结构】中找到相交链表的介绍以及相关题型。

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法 

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    int lena = 1;
    int lenb = 1;
    struct ListNode *cura = headA;
    struct ListNode *curb = headB;
    while(cura->next)
    {
        cura = cura->next;
         lena++;
    }
    while(curb->next)
    {
        curb = curb->next;
        lenb++;
    }
    if(cura != curb)
    {
        return NULL;
    }
    int gap = abs(lena-lenb);
    struct ListNode *llist = headA;
    struct ListNode *slist = headB;
    if(lena > lenb)
    {
       ;
    }
    else
    {
        llist = headB;
        slist = headA;
    }
    while(gap--)
    {
        llist = llist->next;
    }
    while(llist != slist)
    {
         llist = llist->next;
         slist = slist->next;
    }
    return llist;
}
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)
        {
            struct ListNode *meet = slow;
            struct ListNode *newhead = meet->next;
            meet->next = NULL;
            return getIntersectionNode(newhead, head);
        }
    } 
    return NULL;
}

 【leetcode 138.复制带随机指针的链表】

OJ链接

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

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

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

示例 2:

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

输入:head = [[1,1],[2,1]]
输出:[[1,1],[2,1]]

示例 3:

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

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

题目函数接口:

顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

head:目标链表


 这道题比较复杂,拷贝一般链表非常简单,但是这个链表比较特殊,在结构体中加入了随机指针,如果我们先将无random指针链表拷贝一份,再去寻找random指针在链表中指向的位置,会非常麻烦,我们必须不停遍历链表,时间复杂度就非常高O(n^2)。而且代码也会非常的复杂,不建议使用暴力解法。

现在唯一难点就是如何找到新链表中random对应的位置,因为创建新链表与目标链表的地址是没有任何关联的。

但是接下来的方法相对于暴力解法会非常轻松,这个想法也是非常新颖的!!

思路:

我们在原链表中每个结构体的后面插入新的结构体,将对应的内容拷贝到插入的新结构体中,就是这样:顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法

这样我们就可以很方便的寻找random,创建一个指针copy,就比如上图中的13节点,我们需要拷贝13中的random到后面连接的新结构体中,只需要找到旧结构体中random指向的内容,让旧结构体的next的next->random等于copy指向的random即可。顺序表链表OJ题(3)——【数据结构】,C语言,链表,数据结构,c语言,算法 最后一步只需要将完全拷贝好的新结构体拿下来尾插,组成一个新链表即可完成!!!

理论形成,时间开始:

struct Node* copyRandomList(struct Node* head) {
	struct Node*cur = head;
    while(cur)
    {
        struct Node*next = cur->next;
        struct Node*copy = (struct Node*)malloc(sizeof(struct Node));
        copy->val = cur->val;
        cur->next = copy;
        copy->next = next;
        cur = next;
    }
    cur = head;
    while(cur)
    {
        struct Node*copy = cur->next;
        if(cur->random == NULL)
        {
            copy->random = NULL;
        }
        else
        {
            copy->random = cur->random->next;
        }
        cur = copy->next;
    }
    cur = head;
    struct Node*copyhead = NULL;
    struct Node*copytail = NULL;
    while(cur)
    {
        struct Node* copy = cur->next;
        struct Node* next = copy->next;

        if(copytail == NULL)
        {
            copyhead = copytail = copy;
        }
        else
        {
            copytail->next = copy;
            copytail = copytail->next;
        }
        cur->next = next;
        cur = next;
    }
    return copyhead;
}

 新节点插入老节点中、copy指针的寻找新链表……都需要我们画图更好的理解。

这两道题都是想法比较前卫,一般方法比较困难的题,虽然用c语言比较麻烦,但是等到后面我们掌握了map以及哈希结构就会非常简单。

以上就是本次OJ题目的全部内容,希望大家看完有收获,一键三连支持一下博主吧!!!😘😘 文章来源地址https://www.toymoban.com/news/detail-682885.html

到了这里,关于顺序表链表OJ题(3)——【数据结构】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【数据结构与算法】手撕链表OJ题

    给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 思路一 :一种比较普遍的方式,边遍历边找不同。我们可以通过定义两个指针,一个指向头节点,一个置为NULL。当遇到值为相同的时候,直接跳过去。指向下一位

    2024年02月10日
    浏览(42)
  • 【数据结构】C语言实现顺序栈 && OJ题 —— 有效的括号

    👑作者主页:@进击的安度因 🏠学习社区:进击的安度因(个人社区) 📖专栏链接:数据结构

    2024年02月10日
    浏览(42)
  • 【数据结构与算法】:10道链表经典OJ

    思路1:遍历原链表,将 val 所在的节点释放掉。(太麻烦) 思路2:创建新链表,再遍历原链表,找到不为 val 的节点尾插到新链表。 思路1代码实现如下: 注意: 1.当链表为空时,直接返回NULL即可。 2.当尾插上最后一个有效节点时,此时它的 next 可能还与最后一个节点相链接,

    2024年04月14日
    浏览(36)
  • (c语言实现)数据结构链表oj题(2)

    🎈个人主页:🎈 :✨✨✨初阶牛✨✨✨ 🐻推荐专栏: 🍔🍟🌯C语言进阶 🔑个人信条: 🌵知行合一 🍉本篇简介::分析力扣中有关链表的部分题目. 题目来源于:牛客网-题目链接 输入一个链表,输出该链表中倒数第k个结点。 示例: 输入:1,{1,2,3,4,5} 返回值:{5} 创建两个指针: ①

    2024年02月04日
    浏览(54)
  • 【数据结构与算法】一套链表 OJ 带你轻松玩转链表

    ✨个人主页:bit me ✨当前专栏:数据结构 ✨刷题专栏:基础算法   简介: 给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。 示例1: 输入:head = [1,2,6,3,4,5,6], val = 6 输出:[1,2,3,4,5] 示例2: 输入:head = [], val =

    2024年01月22日
    浏览(45)
  • 数据结构c语言版:顺序表oj题练习(原地移除元素、合并两个有序数组)

    在单数组里面历遍找val,如果是val,就删除。不是就跳过。 时间复杂度O(n^2),最坏情况每个都是val。相当于一个等差数列。 比如 下标0开始找,0不是,不动数组 下标1,1不是,不动数组 下标2,2是,删除元素,变成【0,1,2,3,0,4,2】 下标2,2是,删除元素,变成【0,

    2024年01月23日
    浏览(63)
  • 初阶数据结构之---顺序表和链表(C语言)

    线性表: 线性表(linear list)是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构。线性表在逻辑上是线性结构,也就是说是连续的一条直线。但在物理上并不一定是连续的。线性表在物理上存储时,通常以 数组 和 链式结构 的形式存储。

    2024年02月22日
    浏览(64)
  • 【数据结构与算法分析】反转链表与顺序表(内含源码,思路清晰)

      顺序表和链表都是数据结构中常见的线性表。它们的主要区别在于 内存管理方式不同 。   顺序表(Array)是由一系列元素按照一定顺序依次排列而成,它使用连续的内存空间存储数据。顺序表使用一个数组来存储数据,数组中的每个元素都可以通过下标来访问。顺序

    2024年02月07日
    浏览(103)
  • 顺序表和链表【数据结构】【基于C语言实现】【一站式速通】

    目录 顺序表 顺序表的优点 顺序表的实现 1.结构体的定义 2.初始化数组  3.插入数据 4.其余接口函数的实现 5.释放内存 顺序表的缺陷 单向链表 单向链表的优点 单向链表的实现 1.链表的定义  2.链表的初始化 3.其余接口函数的实现 5.释放内存 单向链表的缺陷 双向链表 双向链

    2024年01月24日
    浏览(52)
  • 【数据结构与算法】之8道顺序表与链表典型编程题心决!

                                                                                    个人主页:秋风起,再归来~                                                                                             数据结构与算

    2024年04月14日
    浏览(54)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包