【单链表经典习题讲解】

于 2022-08-09 22:32:09 发布
阅读量658 收藏 26
点赞数 48
分类专栏： 初阶数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68872612/article/details/126237995
版权

 大家好呀，今天向大家分享的是关于单链表的一些比较基础且经典的题目，相信你看完了一定会对单链表的知识掌握的更加熟练。

目录

1 移除链表元素

2 反转链表

3 链表的中间结点

4 链表中倒数第k个结点

 5 合并两个有序链表

6 链表分割

7 链表的回文结构

8 相交链表

9 环形链表

10 环形链表

 

 

 



1 移除链表元素

题目描述：

3faf08e7c1774f8a9c6e5512fa5e5301.png

 解题思路：

遍历链表，用cur表示当前位置，记录要去除元素的前一位地址（prev），让prev->next=cur->next.然后不断迭代，直至cur为空.

但是要额外处理当第一个元素就是要去除元素这种情况。

具体代码实现：

struct ListNode* removeElements(struct ListNode* head, int val)
{
  struct ListNode* prev=NULL;
  struct ListNode* 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;
}

结果展示：

75594522d02f49b48770b50f5b15a771.png

 

2 反转链表

题目描述：

009a4b42159f4c3ba17a56a050f5daf2.png

 解题思路1：

遍历链表，让cur指向当前位置，记录cur前一位的位置prev,记录cur后一位位置next,让cur->next=prev,将prev=cur,cur=next,next=next->next,然后不断迭代，结束条件是cur为NULL，但是要注意当next为NULL时就不要进行next=next->next。

 789e8cdd2f444458838541f3dafbc98f.png

 具体代码：

 ListNode* reverseList(struct ListNode* head)
{
    if(head==NULL)
    {
        return head;
    }
struct ListNode* prev=NULL;
struct ListNode* cur=head;
struct ListNode* next=head->next;

while(cur)
{
    //翻转
    cur->next=prev;

    prev=cur;
    cur=next;
    if(next)
    {
        next=next->next;
    }

}
return prev;
}

结果展示：

7bf692c311404d3695f76f67e79398bb.png

 

解题思路2：

遍历链表，将链表中的元素头插到一个新链表的头上，然后迭代下去，直到cur为NULL，但是要注意保存cur的下一个位置。

具体代码：

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;
}

结果展示：

f63813352cb54a0bafd45f25ff7791e9.png

 两种方法都是可行的，具体用哪一种可以自己选择，但是不要刻意去关注leetcode结果展示中的执行用时和内存消耗，这可能与网速有关。

3 链表的中间结点

题目描述：

435500df58ec496d9aae0184b785630f.png

 解题思路：

常规思路：遍历链表求链表长度，然后再遍历一遍数组求中间结点

具体代码：

struct ListNode* middleNode(struct ListNode* head)
{
int count=0;
struct ListNode* cur=head;
while(cur)
{
    count++;
    cur=cur->next;
}
 cur=head;
 int i=0;
 for(i=0;i<count/2;i++)
 {
     cur=cur->next;
 }
return cur;
}

这种方法可行，但是有没有其他方法只遍历一遍链表呢？

快慢指针：让slow一次走一步，fast一次走两步，直到fast或者fast->next为NULL时结束，此时slow就是中间结点。

具体代码：

struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* slow=head;
    struct ListNode* fast=head;

    while(fast && fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

结果展示：

2b180bbac0164352ab497a2f1ed98441.png

 

4 链表中倒数第k个结点

 

题目描述：

deabb4e1c2de483cbdb8ec770c630ac6.png

 解题思路：

仍然用快慢指针解题，让快指针先走k步，然后同时走。

具体代码：

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    // write code here
    
    struct ListNode* slow=pListHead;
    struct ListNode* fast=pListHead;
    while(k--)
    {
        if(!fast)
            return NULL;
        fast=fast->next;
    }
    while(fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return slow;
    
}

其中值得注意的是当fast先走时并且当fast为空时直接返回NULL。

结果展示：

0b31656343f54542a55b20f909f88bd1.png

 5 合并两个有序链表

题目描述：

dd464e065c5e4bc7ac256c8f1188fd9a.png

 解题思路1：

不创建头结点，一 一遍历两个链表，将较小的值拿下来尾插，然后迭代下去，直至其中一个链表为空，然后把另外一个链表剩下的结点全部链接。但是要注意考虑头为NULL的特殊情况。

具体代码：

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
struct ListNode* head=NULL;
struct ListNode* tail=NULL;
if(list1==NULL)
{
    return list2;
}
if(list2==NULL)
{
    return list1;
}
while(list1 && list2)
{
    if(list1->val < list2->val)
    {
       if(head==NULL)
       {
           tail=head=list1;
       }
       else
       {
            tail->next=list1;
            tail=tail->next;
       }
       list1=list1->next;
    }

    else
    {
       if(head==NULL)
       {
           tail=head=list2;
       }
       else
       {
            tail->next=list2;
            tail=tail->next;
       }
       list2=list2->next;
    }
}
    if(list1)
    {
        tail->next=list1;
    }
    if(list2)
    {
        tail->next=list2;
    }
    return head;
    
}

结果展示：

0bdb1be678f241d8832533ca1c3b9977.png

 解题思路2：

创建一个头结点，不存储数据，方法与第一种类似，但是不需要考虑头为NULL的情况。

具体代码：

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
if(list1==NULL)
{
    return list2;
}
if(list2==NULL)
{
    return list1;
}
struct ListNode* head=(struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* tail=head;


while(list1 && list2)
{
    if(list1->val < list2->val)
    {
       tail->next=list1;
       tail=tail->next;
       list1=list1->next;
    }

    else
    {
       tail->next=list2;
       tail=tail->next;
       list2=list2->next;
    }
}
    if(list1)
    {
        tail->next=list1;
    }
    if(list2)
    {
        tail->next=list2;
    }
    struct ListNode* first=head->next;
    free(head);
    return first;
    
}

结果展示：

a682a31fc44f4accbc1419d467866ff9.png

 这两种方法都是可行的，我个人更喜欢第二种方法。

6 链表分割

题目描述：

d52f2d30b26b4ae6bef4b4fd7e5ebe17.png

解题思路：

创建两个头结点分别连接<x和>=x的链表，最后将较小链表的尾连接到大链表的头的下一位，最后别忘了给大链表的尾置NULL。

 848e4d452f114bc69d5b8caf6eef8dc9.png

具体代码：

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        // write code here
        ListNode*headSmall=(ListNode*)malloc(sizeof(ListNode));
        ListNode*tailSmall=headSmall;
        ListNode*headBig=(ListNode*)malloc(sizeof(ListNode));
        ListNode*tailBig=headBig;
        ListNode*cur=pHead;
        while(cur)
        {
            if(cur->val < x)
            {
                tailSmall->next=cur;
                tailSmall=cur;
                
            }
            else
            {
                tailBig->next=cur;
                tailBig=cur;
            }
            cur=cur->next;
        }
        
        tailSmall->next=headBig->next;
        tailBig->next=NULL;
        return headSmall->next;
    }
};

 

 结果展示：

cce15d7099d345dfb46fe44142122656.png

 

7 链表的回文结构

题目描述：

f7b7666852d7418f80ca77778c9e127c.png

 解题思路：

将链表看作两部分，前半部分和后半部分，再将后半部分逆置一一与前半部分比较，若相等就返回true,否则返回false.这里就不需要将前半部分的尾置为NULL。

具体代码：

struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* slow=head;
    struct ListNode* quick=head;

    while(quick && quick->next)
    {
        slow=slow->next;
        quick=quick->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) {
        // write code here
        ListNode* mid=NULL;
        mid=middleNode(A);
      ListNode* reverse=reverseList(mid);
        while(A && reverse)
        {
            if(A->val != reverse->val)
            {
                return false;
            }
            A=A->next;
            reverse=reverse->next;
        }
        return true;
    }
};

 结果展示：

afdac51315c8424e9e3a035b2bf1aab9.png

 

8 相交链表

题目描述：

48361ec77b2c49a89db81eefce163214.png

 解题思路：

常规思路是遍历其中一个链表，再将该链表与另外一个链表中每个结点比较，这样做时间复杂度为O(N^2),显然是不符合题意的。较为优的解题思路是先判断链表是否相交，然后求链表长度差值，让较长的链表先走差值步，再同时走，直到两个结点相等。

 具体代码：

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    struct ListNode *tailA=headA,*tailB=headB;
    int lenA=1;
    int lenB=1;
    while(tailA->next)
    {
        lenA++;
        tailA=tailA->next;
    }
    while(tailB->next)
    {
        lenB++;
        tailB=tailB->next;
    }
    if(tailA!=tailB)
    {
        return NULL;
    }
    int dis=fabs(lenA-lenB);
    struct ListNode *small=headB;
    struct ListNode *big=headA;
    if(lenA<lenB)
    {
        small=headA;
        big=headB;
    }
    while(dis--)
    {
       big=big->next; 
    }
    while(big!=small)
    {
        big=big->next;
        small=small->next;
    }
    return small;
}

结果展示：

cfd00ad2dcde4750bc3f36758b836e33.png

 

9 环形链表

题目描述：

7df9d9dae6bf45d092b0ca1116cb56d8.png

 解题思路：

定义两个快慢指针，让慢指针一次走一步，快指针一次走两步，当快指针等于慢指针时就返回true,否则返回false.

具体代码：

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(fast==slow)
       {
           return true;
       }
    }
    return false;
}

结果展示：

121e38cc89474ea58a6f5c28ed9c2a75.png

 题后深究：

1 slow一次走一步，fast一次走两步，他们一定会相遇吗？

2 若是slow一次走一步，fast一次走三步会怎样？fast一次走4步会怎样？

 

 063e102e7b194f248892e38bd20eaea3.png

假设slow刚进环时slow与fast之间的距离为X，由于fast每次都比slow快一步，所以他们之间的相对距离在以1之间减少，所以肯定会相遇。

如果fast一次走三步，当X为偶数时，他们一定相遇，当X为奇数时fast肯定在某个情况会恰好超过slow一位，这个时候他们能否相遇取决于C-1的奇偶情况（C表示环的长度），当C-1为奇数时永远不会相遇，当C-1为偶数时会相遇。

a2a0487f18d14548b0b10e971f496db3.png

 当fast一次走四步时也是同样的分析方法。

10 环形链表

题目描述：

d20ef29499144800b057c9a39a8a67e9.png

解题思路：

一个指针从相遇点开始走，一个指针从表头开始走，它们会在环的入口点相遇。

 代码实现：

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *slow=head;
    struct ListNode *fast=head;
    struct ListNode *meetCode=NULL;
    while(fast && fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(fast==slow)
        {
            meetCode=fast;
            slow=head;
            while(slow!=meetCode)
            {
               slow=slow->next;
               meetCode=meetCode->next;
            }
            return slow;
        }
    }
    return NULL;
}

结果展示：

d2713ff5a7624d3fa93d8a45e99e449f.png

 题后深究：

为什么一个指针从相遇点开始走，一个指针从表头开始走，它们会在环的入口点相遇？

07a77c8cce3e4b36ada6adad6e9a502d.png

 由图中公式可知，上述结论是成立的。

 

Fox！
关注
  • 48
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 40
    评论
专栏目录
Python100经典练习题pdf.7z
05-16
Python100经典练习题pdf.7z
单链表结构经典习题
spade_Kwo的博客
12-11 175
文章目录单链表结构经典习题设计一个链表1.尾插法2.头插法3.添加一个新的节点到指定位置4.删除某个中间指定节点5.找到中间某个指定节点6.找出链表长度7.查找单链表中倒数第k个节点8.合并两个有序的链表，保证合并之后的链表依然有序9.不允许改变链表的结构，逆序输出链表10.改变链表的结构，将当前的链表逆置11.两个链表相交，求出相交节点12.判断链表是否带环，并求环的入口点 单链表结构经典习题 设计一个链表 class MySingleList<T> { //永远指向链表当中的第一个节
单链表练习题
m0_48046714的博客
04-29 363
83 class Solution { public ListNode deleteDuplicates(ListNode head) { ListNode dummyHead = new ListNode(101); dummyHead.next = head; ListNode prev = dummyHead; ListNode cur = prev.next; while(cur != null) {
单链表习题
Eriksen的博客
10-18 164
第一个圈 ListNode相当于之前的Node 一个引用类 到之后形成一个节点 第二个圈 定义了两个域 相当于之前的data和next 第三个是 一个构造方法 便于之后用 域 ListNode表示一个返回值 1.移除链表元素 代码如下： public class Eriksenn{ public class ListNode{ int val; ListNode next; ListNode(int x){ ...
单链表的几个题目题解
m0_63185171的博客
07-07 275
主要描述了自己在学习单链表的时候遇到的题目的讲解
java单链表的基本操作 单链表练习题.zip
最新发布
12-20
链表
Python经典100例练习题
05-03
该资源为Python经典100道例练习题
经典EXCEL练习题
05-15
EXCEL练习题，公式练习，经典题目，复杂公式。EXCEL练习题，公式练习，经典题目，复杂公式。
Python100道经典练习题
11-01
关于Python的经典的习题，方便初学者做python知识复习。
单链表相关习题
qq_40179688的博客
10-02 205
1.求单链表节点个数 思路：遍历单链表，每次遍历一个节点计数器加1即可。 public int getlenth() { HeroNode temp=head.next; if(head.next==null) return 0; else { int len=0; while(temp!=null) { len++; temp=temp.next; } return len; } } 2.查找单链表的倒数第k个节点 思路：
单链表习题集锦
Xiao__Tian__的博客
06-23 2810
单链表常见题型汇总 ------（笔试&面试）之不容小觑的单链表
9 道经典单链表题目助你领略单链表逻辑结构的 “魅力”
honglan297的博客
08-01 629
上一篇文章，我们具体讲述了链表的相关知识。本篇紧承上集，通过 9 道单链表较为 ”简单“ 的题目的讲解，让你领略单链表的别样的逻辑结构 “魅力“。同时，单链表作为笔试常考话题之一，简单题目的回顾希望能够帮助大家夯实操作单链表的基础...
单链表的一些练习题
山之巅的专栏
04-28 1431
本来准备自己写一个单链表的排序，但是没写出来，原因是buzhidao
基础数据结构：单链表习题
小柒的秃头之路
09-10 191
习题： 1. a.（4）（1） b.（7）（11）（8）（4）（1） c.（5）（12） d.（9）（4）（1） 2. a.（11）（3）（14） b.（10）（12）（8）（11）（3）（4） c.（10）（12）（7）（3）（4） d.（12）（11）（3）（14） e.（12）（9）（11）（3）（4） 5 #include<stdio.h> #include<math.h> //5 //从前向后 依次头插 void Reverse(PNode plist) { //
excel操作练习题讲解
11-24
Excel操作练习题的讲解可以从以下几个方面展开： 1. 标题和副标题：在Excel的工作表中，应该为每一列的数据设置一个有意义的标题，以便于理解和查找。同时，可以增加副标题，对整个工作表进行简单的介绍。 2. 数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值