【数据结构刷题集】链表经典习题

最新推荐文章于 2024-07-19 23:42:30 发布
最新推荐文章于 2024-07-19 23:42:30 发布
阅读量480 收藏 25
点赞数 32
分类专栏： 数据结构刷题集 文章标签： 数据结构 链表 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59954106/article/details/129734746
版权
😽 PREFACE
🎁欢迎各位→点赞 👍 + 收藏 ⭐ + 评论 📝
📢系列专栏： 数据结构刷题集
🔊本专栏涉及到题目是数据结构专栏的补充与应用，只更新相关题目，旨在帮助提高代码熟练度
💪 种一棵树最好是十年前其次是现在

移除链表元素

题目链接：https://leetcode.cn/problems/remove-linked-list-elements/description/

struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* prev=NULL,*cur=head;
    while(cur)
    {
        if(cur->val==val)
        {
            prev->next=cur->next;
            free(cur);
            cur=prev->next;
        }
        else
        {
            prev=cur;
            cur=cur->next;
        }
    }
    return head;
}

提交一下，我们会发现执行出错。

正确代码：

struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* prev=NULL,*cur=head;
    while(cur)
    {
        if(cur->val==val)
        {
            if(cur==head)
            {
                //头删
                head=cur->next;
                free(cur);
                cur=head;
            }
            else
            {
                prev->next=cur->next;
                free(cur);
                cur=prev->next;
            }  
        }
        else
        {
            prev=cur;
            cur=cur->next;
        }
    }
    return head;
}

链表的中间结点

题目链接：https://leetcode.cn/problems/middle-of-the-linked-list/description/

正确代码：

//尺取法
struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow=head,*fast=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

链表中倒数第k个结点

题目链接：https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&&tqId=11167&rp=2&ru=/activity/oj&qru=/ta/coding-interviews/question-ranking

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast=pListHead,*slow=pListHead;
    while(k--)
    {
        fast=fast->next;
    }
    while(fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return  slow;;
}

结果代码运行不过：

正确代码：

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast=pListHead,*slow=pListHead;
    while(k--)
    {
        if(fast==NULL)//防止越界
        {
            return NULL;
        }
        fast=fast->next;
    }
    while(fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return  slow;;
}

反转链表

题目链接：https://leetcode.cn/problems/reverse-linked-list/description/

法一：画图+迭代

//画图+迭代
struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* prev,*cur,*next;
    prev=NULL,cur=head,next=head->next;
    while(cur)
    {
        //反转
        cur->next=prev;
        //迭代
        prev=cur;
        cur=next;
        next=next->next;
    }
    return prev;
}

这个只是最基本的逻辑，一运行发现还是过不了

//画图+迭代
struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* prev,*cur,*next;
    prev=NULL,cur=head,next=head->next;
    while(cur)
    {
        //反转
        cur->next=prev;
        //迭代
        prev=cur;
        cur=next;
        if(next)
            next=next->next;
    }
    return prev;
}

再次提交，发现还是过不去：

正确代码1：

//画图+迭代
struct ListNode* reverseList(struct ListNode* head){
    if(head==NULL)
        return NULL;
    struct ListNode* prev,*cur,*next;
    prev=NULL,cur=head,next=head->next;
    while(cur)
    {
        //反转
        cur->next=prev;
        //迭代
        prev=cur;
        cur=next;
        if(next)
            next=next->next;
    }
    return prev;
}

法二：头插

为什么能想到头插呢？因为头插的顺序与链表的顺序刚好相反。

正确代码2：

//头插
struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* cur=head, *newhead=NULL;
    while(cur)
    {
        struct ListNode* next=cur->next;
        //头插
        cur->next=newhead;
        newhead=cur;

        cur=next;
    }
    return newhead;
}

合并两个有序链表

题目链接：https://leetcode.cn/problems/merge-two-sorted-lists/description/

法一：不带哨兵位头结点

//不带哨兵位头结点
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode* cur1=list1,*cur2=list2;
    struct ListNode* head=NULL,*tail=NULL;
    while(cur1&&cur2)
    {
        if(cur1->val<cur2->val)
        {
            if(head==NULL)
            {
                head=tail=cur1;
            }
            else
            {
                tail->next=cur1;
                tail=tail->next;
            }
            cur1=cur1->next;
        }
        else
        {
            if(head==NULL)
            {
                head=tail=cur2;
            }
            else
            {
                tail->next=cur2;
                tail=tail->next;
            }
            cur2=cur2->next;
        }
    }
    if(cur1)
    {
        tail->next=cur1;
    }
    if(cur2)
    {
        tail->next=cur2;
    }
    return head;
}

正确代码1：

//不带哨兵位头结点
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    //如果链表为空，返回另一个
    if(list1==NULL)
    {
        return list2;
    }
    if(list2==NULL)
    {
        return list1;
    }
    struct ListNode* cur1=list1,*cur2=list2;
    struct ListNode* head=NULL,*tail=NULL;
    while(cur1&&cur2)
    {
        if(cur1->val<cur2->val)
        {
            if(head==NULL)
            {
                head=tail=cur1;
            }
            else
            {
                tail->next=cur1;
                tail=tail->next;
            }
            cur1=cur1->next;
        }
        else
        {
            if(head==NULL)
            {
                head=tail=cur2;
            }
            else
            {
                tail->next=cur2;
                tail=tail->next;
            }
            cur2=cur2->next;
        }
    }
    if(cur1)
    {
        tail->next=cur1;
    }
    if(cur2)
    {
        tail->next=cur2;
    }
    return head;
}

法二：带哨兵位头结点

正确代码2：

//带哨兵位头结点
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    struct ListNode* cur1=list1,*cur2=list2;
    struct ListNode* guard=NULL,*tail=NULL;
    guard=tail=(struct ListNode*)malloc(sizeof(struct ListNode));
    tail->next=NULL;
    while(cur1&&cur2)
    {
        if(cur1->val<cur2->val)
        {
            tail->next=cur1;
            tail=tail->next;
            cur1=cur1->next;
        }
        else
        {
            tail->next=cur2;
            tail=tail->next;
            cur2=cur2->next;
        }
    }
    if(cur1)
    {
        tail->next=cur1;
    }
    if(cur2)
    {
        tail->next=cur2;
    }
    struct ListNode* head=guard->next;//防止内存泄漏
    free(guard);
    return head;
}

链表分割

题目链接：https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId=8&&tqId=11004&rp=2&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        struct ListNode* lessguard,*lesstail,*greaterguard,*greatertail;
        lessguard=lesstail=(struct ListNode*)malloc(sizeof(struct ListNode));
        greaterguard=greatertail=(struct ListNode*)malloc(sizeof(struct ListNode));
        lesstail->next=greatertail->next=NULL;

        struct ListNode* cur=pHead;
        while(cur)
        {
            if(cur->val<x)
            {
                lesstail->next=cur;
                lesstail=lesstail->next;
            }
            else
            {
                greatertail->next=cur;
                greatertail=greatertail->next;
            }
            cur=cur->next;
        }
        lesstail->next=greaterguard->next;

        pHead=lessguard->next;
        free(greaterguard);
        free(lessguard);
        return pHead;
    }
};

运行一下：

由于牛客不提供用例错误，我们可以转到力扣官网上查。当然了，也可以把我们写的用例往代码带，看看哪出错了。

正确代码：

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        struct ListNode* lessguard,*lesstail,*greaterguard,*greatertail;
        lessguard=lesstail=(struct ListNode*)malloc(sizeof(struct ListNode));
        greaterguard=greatertail=(struct ListNode*)malloc(sizeof(struct ListNode));
        lesstail->next=greatertail->next=NULL;

        struct ListNode* cur=pHead;
        while(cur)
        {
            if(cur->val<x)
            {
                lesstail->next=cur;
                lesstail=lesstail->next;
            }
            else
            {
                greatertail->next=cur;
                greatertail=greatertail->next;
            }
            cur=cur->next;
        }
        lesstail->next=greaterguard->next;
        greatertail->next=NULL;//不能忽略
        pHead=lessguard->next;
        free(greaterguard);
        free(lessguard);
        return pHead;
    }
};

链表的回文结构

题目链接：https://www.nowcoder.com/practice/d281619e4b3e4a60a2cc66ea32855bfa?tpId=49&&tqId=29370&rp=1&ru=/activity/oj&qru=/ta/2016test/question-ranking

正确代码：

//找中间节点
struct ListNode* middleNode(struct ListNode* head) {
    struct ListNode* slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}
//反转
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* cur = head;
    struct ListNode* newhead = NULL;
    while (cur) {
        struct ListNode* next = cur->next;
        //头插
        cur->next = newhead;
        //迭代
        newhead = cur;
        cur = next;
    }
    return newhead;
}

class PalindromeList {
  public:
    bool chkPalindrome(ListNode* A) {
        struct ListNode* mid=middleNode(A);
        struct ListNode* rHead=reverseList(mid);

        struct ListNode* curA=A;
        struct ListNode* curR=rHead;
        while(curA&&curR)
        {
            if(curA->val!=curR->val)
            {
                return false;
            }
            else
            {
                curA=curA->next;
                curR=curR->next;
            }
        }
        return  true;
    }
};

相交链表

题目链接：https://leetcode.cn/problems/intersection-of-two-linked-lists/description/

正确代码：

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* tailA=headA,*tailB=headB;
    int lenA=0,lenB=0;
    while(tailA)
    {
        lenA++;
        tailA=tailA->next;
    }
    while(tailB)
    {
        lenB++;
        tailB=tailB->next;
    }

    //不相交的情况,不写的话leetcode也不会判错
    if(tailA!=tailB)
    {
        return NULL;
    }

    int gap=abs(lenA-lenB);
    struct ListNode* longList=headA,*shortList=headB;
    if(lenA<lenB)
    {
        longList=headB;
        shortList=headA;
    }

    while(gap--)
    {
        longList=longList->next;
    }

    while(longList!=shortList)
    {
        longList=longList->next;
        shortList=shortList->next;
    }
    return shortList;
}

环形链表

题目链接：https://leetcode.cn/problems/linked-list-cycle/description/

正确代码：

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

环形链表II

题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/description/

法一：双指针

正确代码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* meetNode=slow;
            //公式
            while(meetNode!=head)
            {
                meetNode=meetNode->next;
                head=head->next;
            }
            return head;
        }
    }
    return NULL;
}

法二:转化成链表相交

正确代码2：

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* tailA=headA,*tailB=headB;
    int lenA=0,lenB=0;
    while(tailA)
    {
        lenA++;
        tailA=tailA->next;
    }
    while(tailB)
    {
        lenB++;
        tailB=tailB->next;
    }

    //不相交的情况,不写的话leetcode也不会判错
    if(tailA!=tailB)
    {
        return NULL;
    }

    int gap=abs(lenA-lenB);
    struct ListNode* longList=headA,*shortList=headB;
    if(lenA<lenB)
    {
        longList=headB;
        shortList=headA;
    }

    while(gap--)
    {
        longList=longList->next;
    }

    while(longList!=shortList)
    {
        longList=longList->next;
        shortList=shortList->next;
    }
    return shortList;
}


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* meetNode=slow;
            struct ListNode* list1=meetNode->next;
            struct ListNode* list2=head;
            meetNode->next=NULL;
            return getIntersectionNode(list1,list2);
        }
    }
    return NULL;
}

复制带随机指针的链表

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

正确代码：

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 copy 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.拆组
    struct Node* copyHead=NULL,*copyTail=NULL;
    cur=head;
    while(cur)
    {
        struct Node* copy=cur->next;
        struct Node* next=copy->next;

        //copy尾插
        if(copyHead==NULL)
        {
            copyHead=copyTail=copy;
        }
        else
        {
            copyTail->next=copy;
            copyTail=copyTail->next;
        }

        //恢复原链表
        cur->next=next;
        cur=next;
    }
    return copyHead;
}

「已注销」
关注
  • 32
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 40
    评论
专栏目录
期末刷题数据结构习题集
10-05
数据结构习题集 数据结构是计算机科学中的一种重要概念，涉及到数据的存储、组织和操作。下面是根据所给文件信息生成的知识点摘要： 1. 字符串是一种数据结构，串是字符的有限序列，空串是由空格构成的串，模式...
初学数据结构时候做的练习题集合笔记
04-02
这篇初学者的练习题集合笔记主要关注了两种基本数据结构：数组和链表，并对它们的优缺点进行了比较。同时，笔记也提到了平衡二叉树作为提高查找效率的一种高级数据结构。 数组是一种线性数据结构，其中元素存储在...
Leetcode：链表刷题（7道经典题目）
一起加油~
03-22 1646
Leetcode：链表刷题 列出了一些关于链表的经典题目，并提供了对应的题解。主要是用C++实现的。对于使用其他语言的童鞋，可以很好的迁移过去。
链表 回文结构
weixin_43914278的博客
06-13 406
对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。 给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。 import java.util.*; /* public class ListNode { int val; ListNode next = null; Lis...
链表刷题集
yajunjiao的专栏
04-30 1075
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
数据结构与算法-链表（练习一）
LoveXming的博客
03-12 1404
数据结构与算法-链表练习
大厂算法和数据结构刷题班.zip
03-03
在编程领域，尤其是在面试准备阶段，"大厂算法和数据结构刷题班"是一个非常重要的主题。这个压缩包文件很可能是包含一系列课程资料、练习题和解决方案，旨在帮助程序员提升算法和数据结构能力，以便更好地应对大型...
DataStructure：图解数据结构刷题代码
02-09
《数据结构：图解刷题代码解析》 在编程领域，数据结构是基础中的基础，它关乎程序的效率和可维护性。本资料主要聚焦于使用Java语言来理解和实现常见数据结构，结合LeetCode上的算法题目，以实战的方式加深对数据...
数据结构第32节 无锁编程
hummhumm的专栏
07-17 832
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 786
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1880
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 230
1%29%5D。
数据结构——栈
weixin_45942515的博客
07-19 171
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
《数据结构》预备
U2396573637的博客
07-19 483
位段的声明和结构体是类似的，有两个不同：1.位段的成员必须是int、unsigned int、 signed int，在C99中位段成员也可以选择其它类型。2.位段的成员后边有一个冒号和一个数字。int _b:5;int _c:10;int _d:30;A就是一个位段类型。那位段A所占内存的大小是多少呢？
数据结构(5.2_3)——二叉树的存储结构
最新发布
m0_65240792的博客
07-19 162
1%29%5D1。
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 375
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
数据结构（队列）
2401_83968713的博客
07-19 452
这么看好像两者的差别不大，但是我们在单链表结构中可以稍作改造，直接定义两个结点（头结点，尾结点）指向原链表的队头和队尾，那么在队尾入数据时就不用遍历链表，直接让尾结点->next 等于新结点，时间复杂度就变成 O(1)了。概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)⼊队列操作的时间复杂度为 O(1) ,进行出队列操作的时间复杂度为 O(n);⼊队列：进⾏插⼊操作的⼀端称为队尾。出队列：进⾏删除操作的⼀端称为队头。
数据结构_排序
m0_73620971的博客
07-19 638
1、希尔排序是对直接插入排序的优化。2、直接选择排序效率不高，很少使用；堆排序效率高。3、快速排序综合性能和使用场景都是比较好的。4、归并排序更多是在解决磁盘中的外排序问题。
菜鸟成长记：数据结构练习与数组链表深度解析
总结来说，学习数据结构不仅要掌握基本概念，还要通过练习题来理解不同数据结构在不同场景下的性能差异，并学会根据实际需求选择合适的数据结构。理解内存访问模式、缓存层次以及算法优化策略，是提升代码效率的关键...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 40
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值