当前位置： 首页 > news >正文

【数据结构】单链表的经典算法题

news 2025/11/9 7:10:34

1单链表算法题

1.1 移除链表元素

题目链接

思路一：查找值为val的结点并返回结点，返回指定位置的结点

while(遍历)---O(N)
{//查找值为val的结点if()//删除值为val的结点---O(N)
}

思路二：创建新链表，将原链表中不为val结点拿来尾插

//时间复杂度O(N)
//结构体已经定义了
struct ListNode
{int val;struct ListNode* next;
};
typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head,int val)
{//创建新的链表ListNode* newHead,*newTail;newHead=newTail=NULL;ListNode* pcur=head;while(pcur){if(pcur->val!=val){//尾插//链表为空if(newHead==NULL)newHead=newTail=pcur;else{//链表非空newTail->next=pcur;newTail=newTail->next;}}pcur=pcur->next;}if(newTail)newTail->next=NULL;return newHead;
}

OJ代码有bug怎么办？VS调试技能⽤起来

1）将OJ代码复制粘贴到vs上

2）创建测试⽅法，调⽤本次要调试的⽬标⽅法

3）利⽤vs调试⼯具排查代码问题

//调试
void test01()
{//创建新链表ListNode* node1=(ListNode*)malloc(sizeof(ListNode));ListNode* node2=(ListNode*)malloc(sizeof(ListNode));ListNode* node3=(ListNode*)malloc(sizeof(ListNode));ListNode* node4=(ListNode*)malloc(sizeof(ListNode));ListNode* node5=(ListNode*)malloc(sizeof(ListNode));ListNode* node6=(ListNode*)malloc(sizeof(ListNode));ListNode* node7=(ListNode*)malloc(sizeof(ListNode));node1->val=1;node2->val=2;node3->val=6;node4->val=3;node5->val=4;node6->val=5;node7->val=6;node1->next=node2;node2->next=node3;node3->next=node4;node4->next=node5;node5->next=node6;node6->next=node7;node7->next=NULL;ListNode* newHead=removeElements()
}

1.2 反转链表

题目链接

思路一：创建新链表，遍历原链表将结点头插到新链表中

时间复杂度O(N)

思路二：

//时间复杂度o(N)
typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head)
{if(head==NULL)return head;ListNode* n1,*n2,*n3;n1=NULL;n2=head;n3=n2->next;while(n2)//以n2为判断条件，不能以n3为判断条件，因为最后n2的下一个要为NULL，如果n3为判断条件，n2最后不会被赋值{n2->next=n1;n1=n2;n2=n3;if(n3)n3=n3->next;}return n1;
}

此时的结果图

在这里插入图片描述

1.3 链表的中间结点

题目链接

思路一：求链表总长度，总长度/2再取整就是中间结点位置，遍历找中间结点

while()//求总长度
{
}//size++
int mid=size//2;
while(mid)//根据mid找中间位置

在这里插入图片描述

思路二：快慢指针，慢指针每次走一步，快指针每次走两步

typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head)
{//创建快慢指针ListNode* slow=head;ListNode* fast=head;while(fast!=NULL&&fast->next!=NULL)//不能写成fast->next!=NULL&&fast!=NULL//如果是偶数，fast不为空时，会执行fast->next->next，此时是对空指针的解引用{slow=slow->next;fast=fast->next->next;}return slow;
}

1.4 合并两个有序链表

题目链接

思路：创建新链表，遍历比较，谁小谁往后放

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1,struct ListNode* list2)
{if(list1==NULL)//同时为空也会进入if语句return list2;if(list==NULL)return list1;//创建空链表ListNode* newnode,*newTail；ListNode* l1=list1;ListNode* l2=list2;while(l1!=NULL&&l2!=NULL){if(l1->val<l2->val){if(newHead==NULL)newHead=newTail=l1;else{newTail->next=l1;newTail=newTail->next;}l1=l1->next;}else{if(newHead==NULL)newHead=newTail=l2;else{newTail->next=l2;newTail=newTail->next;}l2=l2->next;}}//l1和l2不可能同时为空，除非给了两个空链表if(l1)//不需要用whilenewTail->next=l1;//也不需要让newTail=newTail->next，因为l1自带指向if(l2)newTail->next=l2;return newHead;
}

在这里插入图片描述

优化如下：

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1,struct ListNode* list2)
{if(list1==NULL)//同时为空也会进入if语句return list2;if(list==NULL)return list1;//创建非空链表ListNode* newnode,*newTail；newHead=newTail=(ListNode*)malloc(sizeof(ListNode));while(l1!=NULL&&l2!=NULL){if(l1<l2){newTail->next=l1;newTail=newTail->next;l1=l1->next;}else{newTail->next=l2;newTail=newTail->next;l2=l2->next;}}//l1和l2不可能同时为空，除非给了两个空链表if(l1)//不需要用whilenewTail->next=l1;//也不需要让newTail=newTail->next，因为l1自带指向if(l2)newTail->next=l2;//newHead是malloc创建的新结点，不是链表的首结点ListNode* retHead=newHead->next;//newHead->next才是首结点//好习惯是用另一个变量接收首结点地址，再将newHead释放free(newHead);newHead=NULL;return retHead;
}

在这里插入图片描述

1.5 链表分割

题目链接

思路：创建两个链表（大链表和小链表），遍历原链表，小的尾插到小链表中，大的尾插到大链表中，最后大小链表首尾相连

在这里插入图片描述

/*
struct ListNode {int val;struct ListNode *next;ListNode(int x) : val(x), next(NULL) {}
};*/
class Partition {
public:ListNode* partition(ListNode* pHead, int x) {ListNode* lessHead,*lessTail;lessHead=lessTail=(ListNode*)malloc(sizeof(ListNode));ListNode* greatHead,* greatTail;greatHead=greatTail=(ListNode*)malloc(sizeof(ListNode));ListNode* pcur=pHead;while(pcur){if(pcur->val<x){//lessHead有头结点，可以直接解引用lessTail->next=pcur;lessTail=lessTail->next;}//大于等于都在这里else{greatTail->next=pcur;greatTail=greatTail->next;}pcur=pcur->next;}//大链表尾结点置为NULLgreatTail->next=NULL;//大小链表首尾相连lessTail->next=greatHead->next;ListNode* ret=lessHead->next;free(lessHead);free(greatHead);return ret;}
};

1.6 链表的回⽂结构

题目链接

回文结构：“abcba”，“12344321”，类似“轴对称”结构

思路一：创建新链表保存原链表所有的结点，反转新链表，比较新旧链表中的结点是否相同

思路二：（投机取巧）创建数组（大小为900），遍历链表将结点的值依次存储在数组中，若数组为回文结构，则链表为回文结构

class PalindromeList
{pubilc:bool chkPalindrome(ListNode* A){int arr[900]={0};//o(900)==o(1)//遍历链表，将链表中结点的值依次存储到数组中ListNode* pcur=A;//cpp不需要typedef，可以直接用while(pcur){arr[i++]=pcur->val;pcur=pcur->next;}//判断数组是否为回文结构int left=0;int right=i-1;while(left<right){if(arr[left]!=arr[right])return false;left++;right--;}return true;}
}

思路三：找中间结点，将中间结点作为新链表的头结点，反转链表，遍历原链表和反转后链表结点的值是否相等

class PalindromeList
{public://找中间结点ListNode* middleNode(struct ListNode* head){//创建快慢指针ListNode* slow=head;ListNode*fast=head;while(fast!=NULL&&fast->next!=NULL){slow=slow->next;fast=fast->next->next;}return slow;}//反转链表
ListNode* reverseList(struct ListNode* head)
{if(head==NULL)return head;ListNode* n1,*n2,*n3;n1=NULL;n2=head;n3=n2->next;while(n2)//以n2为判断条件，不能以n3为判断条件，因为最后n2的下一个要为NULL，如果n3为判断条件，n2最后不会被赋值{n2->next=n1;n1=n2;n2=n3;if(n3)n3=n3->next;}return n1;//链表的新的头结点
}bool chkPalindrome(ListNode* A){//找中间结点ListNode* mid=middleNode(A);//反转以中间结点为头的链表ListNode* right=reverseList(mid);//遍历原链表和反转后的链表，比较结点的值是否相等ListNode* left=A;while(right){if(left->val!=right->val)return false;left=left->next;right=right->next;}return true;}
};

1.7 相交链表

题目链接

思路：求两个链表的长度，长链表先走长度差步，长短链表开始同步遍历，找相同的结点

typedef struct ListNode ListNode;
struct ListNode* getIntersectionNode(struct ListNode* headA,struct ListNode* headB)
{ListNode* pa=HeadA;ListNode* pb=HeadB;int sizeA=0,sizeb=0;while(pa){++size;pa=pa->next;}while(pb){++size;pb=pb->next;}//求长度差int gap=abs(sizeA-sizeB);//求绝对值//谁是长链表ListNode* shortlist=headA;//先让A链表为短ListNode* longList=headB;//指针减指针也可以求距离，但是不好判断谁是长链表if(sizeA>sizeB)//如果A长，则修改A为长链表{longList=headA;shortList=headB;}//让长链表先走gapwhile(gap--){longList=longList->next;}//此时长短链表在同一起跑线while(shortList)//或者while(longList){if(shortList==longList){return shortList;//也可以返回longList}shortList=shortList->next;longList=longList->next;}//链表不相交return NULL;
}

相交：

在这里插入图片描述

不相交：

在这里插入图片描述

1.8 环形链表I

题目链接

思路：快慢指针，慢指针每次走一步，快指针每次走两步，如果slow和fast指向同一个结点，则链表带环

在这里插入图片描述

typedef struct ListNode ListNode;
bool hasCycle(struct ListNode* head)
{//创建快慢指针ListNode* slow=head;ListNode* fast=head;while(fast&&fast->next)//如果不带环，fast(偶数个)&&fast->next(奇数个)会为空，只要为空，跳出循环返回false{slow=slow->next;fast=fast->next->next;if(slow==fast)return ture;}//链表不带环return false;
}

思考1：为什么快指针每次⾛两步，慢指针⾛⼀步可以相遇，有没有可能遇不上，请推理证明！

在这里插入图片描述

slow⼀次⾛⼀步，fast⼀次⾛2步，fast先进环，

假设slow也⾛完⼊环前的距离，准备进环，此时fast 和slow之间的距离最大为N，

接下来的追逐过程中，每追击⼀次，他们之间的距离缩⼩1步

追击过程中fast和slow之间的距离变化：

在这里插入图片描述

因此，在带环链表中慢指针⾛⼀步，快指针⾛两步最终⼀定会相遇。

思考2：快指针⼀次⾛3步，⾛4步，…n步⾏吗?

step1: 按照上⾯的分析，慢指针每次⾛⼀步，快指针每次⾛三步，此时快慢指针的最⼤距离为N，

接下来的追逐过程中，每追击⼀次，他们之间的距离缩⼩2步

追击过程中fast和slow之间的距离变化：

在这里插入图片描述

分析: 1、如果N是偶数，会相遇

2、如果N是奇数，第⼀轮追不上，快追上，错过了，距离变成-1，即C-1，进⼊新的⼀轮追击

a、C-1如果是偶数，那么下⼀轮就追上了

b、C-1如果是奇数， 那么就永远都追不上

总结⼀下追不上的前提条件： N是奇数，C是偶数

step2：

假设： 环的周⻓为C，头结点到slow结点的⻓度为L，slow⾛⼀步，fast⾛三步，当slow指针⼊环后， slow和fast指针在环中开始进⾏追逐，假设此时fast指针已经绕环x周。

在这里插入图片描述

在追逐过程中，快慢指针相遇时所⾛的路径⻓度:

fast: L+xC+C-N

slow：L

由于慢指针⾛⼀步，快指针要⾛三步，因此得出： 3 * 慢指针路程 = 快指针路程 ，即： 3L = L + C − N+ xC，所以2L = (x + 1)C − N

对上述公式继续分析：由于偶数乘以任何数都为偶数，因此⼀定为偶数，则可推导出可能得情况： 2L

• 情况1：偶数=偶数-偶数

• 情况2：偶数=奇数-奇数 由step1中（1）得出的结论，如果N是偶数，则第⼀圈快慢指针就相遇了。 由step1中（2）得出的结论，如果N是奇数，则fast指针和slow指针在第⼀轮的时候套圈了，开始进⾏下⼀轮的追逐；当N是奇数，要满⾜以上的公式，x+1和C都必须为奇数，满⾜相遇结论，则快慢指针会相遇

因此，既然不存在N是奇数，C是偶数的情况，则快指针⼀次⾛3步最终⼀定也可以相遇。

快指针⼀次⾛4、5…步最终也会相遇，其证明⽅式同上。

typedef struct ListNode ListNode; 
bool hasCycle(struct ListNode *head) 
{ ListNode* slow,*fast; slow = fast = head; while(fast && fast->next) { slow = slow->next; int n=3; //fast每次⾛三步 while(n--)//可能一个循环里不能直接走三步，不能直接修改外部while判断条件 { if(fast->next) fast = fast->next; else return false; } if(slow == fast) { return true; } } return false; 
}

提⽰ 虽然已经证明了快指针不论⾛多少步都可以满⾜在带环链表中相遇，但是在编写代码的时候会有额外的步骤引⼊，涉及到快慢指针的算法题中通常习惯使⽤慢指针⾛⼀步快指针⾛两步的⽅式。

1.9 环形链表II

题目链接

思路：相遇点到入环结点的距离==头结点到入环结点的距离

typedef struct ListNode ListNode;
struct NodeList* detectCycle(struct ListNode* head) 
{//创建快慢指针ListNode* slow=head;ListNode* fast=head;while(fast&&fast->next)//如果不带环，fast(偶数个)&&fast->next(奇数个)会为空，只要为空，跳出循环返回false{slow=slow->next;fast=fast->next->next;if(slow==fast){//相遇了，接下来找入环结点ListNode* pcur=head;//slow和pcur同时走，相遇的位置就是入环结点while(pcur!=slow)//用fast也行{pcur=pcur->next;slow=slow->next;}return pcur;//return slow;}}//链表不带环return NULL;
}

那为什么相遇点到入环结点的距离==头结点到入环结点的距离？

在这里插入图片描述

说明: H为链表的起始点，E为环⼊⼝点，M是相遇点

设: 环的⻓度为R，H到E的距离为L，E到M的距离为 X ，则：M到E的距离为 R-X

相遇时，快慢指针相遇时所⾛的路径⻓度: fast: L+X + nR slow：L+X

注意: 1.当慢指针进⼊环时，快指针可能已经在环中绕了n圈了，n⾄少为1

因为快指针先进环⾛到M的位置，最后⼜在M的位置与慢指针相遇

2.慢指针进环之后，快指针肯定会在慢指针⾛⼀圈之内追上慢指针

因为：慢指针进环后，快慢指针之间的距离最多就是环的⻓度，⽽两个指针在移动时，每次它们⾄今的距离都缩减⼀步，因此在慢指针移动⼀圈之前快指针肯定是可以追上慢指针的，⽽快指针速度是满指针的两倍，因此有如下关系是：

2 * (L+X)=L+X+nR

L+X=nR

L=nR-X

L=nR+R-R-X

L = (n-1)R+(R-X) (n为1,2,3,4…，n的⼤⼩取决于环的⼤⼩，环越⼩n越⼤)

L是头结点到入环结点的距离，R-X是相遇点到入环结点的距离，(n-1)R是整圈

极端情况下，假设n=1，此时： L=R-X 即：⼀个指针从链表起始位置运⾏，⼀个指针从相遇点位置绕环，每次都⾛⼀步，两个指针最终会在⼊⼝点的位置相遇

1.10 随机链表的复制

题目链接

深度拷贝是指在复制对象时，不仅复制对象本身，还递归地复制其所有子对象，从而使新对象与原对象完全独立。与之相对的是浅拷贝，浅拷贝只复制对象的引用，导致新旧对象共享内存。

思路：在原有链表基础上拷贝

拷贝random时的思路：如果pcur->random不为空，则拷贝出来的结点的random==pcur->next->random

在这里插入图片描述

/*** Definition for a Node.* struct Node {*     int val;*     struct Node *next;*     struct Node *random;* };*/
typedef struct Node Node;
//封装一个函数用来创建结点
Node* buyNode(int x)
{Node* newnode=(Node*)malloc(sizeof(Node));newnode->val=x;//先把next和random置为空newnode->next=newnode->random=NULL;return newnode;
}
//拷贝结点（除random以外的）
void AddNode(Node* head)
{Node* pcur=head;while(pcur){//将pcur的值先拷贝Node* newnode=buyNode(pcur->val);//先将原链表pcur下一个结点存起来Node* next=pcur->next;newnode->next=next;pcur->next=newnode;pcur=next;//也可以先连再断//newnode->next=pcur->next;//pcur->next=newnode;//pcur=newnode->next;}}
void setRandom(Node* head)
{Node* pcur=head;while(pcur){Node* copy=pcur->next;//现在要修改randomif(pcur->random)copy->random=pcur->random->next;pcur=copy->next;//指向原链表的下一个结点//else//    copy->random=NULL;//不需要这两句代码，因为这段代码的意思是//pcur->random为空，要给对应新链表的结点的random赋值为NULL，但是新链表的结点的random本来就是NULL//不需要再次赋值}
}
struct Node* copyRandomList(struct Node* head) 
{//如果是空链表if(head==NULL)return head;//1.在原链表基础上拷贝结点并插入原链表中AddNode(head);//2.设置randomsetRandom(head); //3.与新链表断开Node* pcur=head;Node* copyHead,copyTail;copyHead=copyTail=pcur->next;//只要新链表结点的尾结点不为空while(copyTail->next){pcur=copyTail->next;copyTail->next=pcur->next;copyTail=copyTail->next;}return copyHead;
}

在这里插入图片描述

更多链表算法刷题⼊⼝：

牛客网

LeetCode

http://www.dtcms.com/a/585251.html

相关文章：

  • 网站优化要用什么软件做公司网站哪家好
  • 【DaisyUI】select 和 dropdown 怎么选择？
  • 如何进行oracle提权？
  • K8s API Server 核心解析：集群的“中枢神经”与功能全解
  • 简单两步将你的python转成exe格式
  • 混合澄清槽在氧化铜矿石湿法萃取中的应用
  • Vue3 + TypeScript学习
  • GitHub Action工作流语法
  • 动态效果网站建设技术广东省建筑工程信息网
  • cpp_list
  • rk3588上用rk_mpi_vi_test与ffmpeg实战
  • Rust 练习册 ：Queen Attack与国际象棋逻辑
  • CSS学习
  • 使用V4L2工具验证RK3588平台视频设备节点数据有效性
  • Rust 练习册 ：Protein Translation与生物信息学
  • 网站开发课程知识点总结图片自动生成器
  • 【STL——常用遍历与查找算法】
  • 牛客网华为在线编程题
  • 29网站建设全部400网站总机 阿里云
  • 第四章 依赖项属性
  • wpf 结合 HALCON 编程 学习知识点列表有哪些？如何学习？
  • 学习C#调用OpenXml操作word文档的基本用法（5：Style类分析-3）
  • 系统运维Day03_FTP与磁盘挂载
  • 嘉兴网站备案去哪里优化网站是什么意思
  • SQL笔试题(2)
  • MATLAB/Simulink三机九节点
  • JVM 内存结构与 GC 调优全景图
  • 4.3.5【2024统考真题】
  • 如何进行MSSQL提权？sp_oacreate、sp_oamethod和沙盒提权以及xp_regwrighte提权
  • AI大模型开发架构设计（23）——LangChain技术架构和关键技术深度剖析