leetcode链表相关题目

文章目录

  • 1.移除链表元素
    • 方法1：
    • 方法2
  • 2.合并两个有序链表
  • 3.链表的中间节点
    • 方法1
    • 方法2
  • 4.反转单链表
    • 方法1
    • 方法2
  • 5.分割链表
  • 6.链表中的倒数第k个节点
    • 方法1：
    • 方法2:
  • 7.环形链表的约瑟夫问题
  • 8.链表的回文结构
  • 9.相交链表
    • 方法1
    • 方法2：
  • 10.环形链表
  • 11.环形链表Ⅱ
  • 12.随机链表的复制

在这里插入图片描述
链表学习完以后，来做点相关题目吧

1.移除链表元素

在这里插入图片描述

方法1：

在原链表的基础上直接删除指定元素

  • 若当前节点是要删除的节点，则将其前驱节点指向当前节点的下一个节点
  • 若当前节点不是要删除的节点，前驱节点指向当前节点，当前节点后移
  • 特殊情况：
    • 循环判断，若头节点是要删除的节点，则将头节点后移
    • 头节点不为空
struct ListNode* removeElements(struct ListNode* head, int val) {struct ListNode* cur = head;struct ListNode* prev = head;//判断头节点while(head && head->val == val){head = head->next;}//链表为空if(head == NULL){return NULL;}//正常情况while(cur){if(cur->val == val){prev->next = cur->next;}else{prev = cur;}cur =  cur->next;}return head;
}

方法2

创建一个新的链表存放未删除的元素

  • 先创建一个虚拟的头节点，指向新链表，同时记录该链表的尾
  • 若当前节点是要删除的元素，直接后移
  • 若当前节点不是要删除的元素，连接到新链表的尾后
  • 将新链表尾节点的next置为空（断开与原链表的连接）
struct ListNode* removeElements(struct ListNode* head, int val) {//设置新链表的头struct ListNode* newhead = (struct ListNode*)malloc(sizeof(struct ListNode));newhead->val = -1;newhead->next = NULL;struct ListNode* cur = head;struct ListNode* tail = newhead;while(cur){if(cur->val == val){cur = cur->next;}else{tail->next = cur;tail = tail->next;cur = cur->next;}}//将新链表与原链表断开tail->next = NULL;struct ListNode* ret = newhead->next;free(newhead);newhead = tail = NULL;return ret;
}

2.合并两个有序链表

在这里插入图片描述

创建一个新的链表

  • 两个指针分别指向两个链表
  • 将两指针所指向的元素的较小值连接到新链表的尾
  • 若有一个指针走到空，则将另一个指针连接到新链表的尾
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {//定义新链表的头struct ListNode* newhead = (struct ListNode*)malloc(sizeof(struct ListNode));newhead->val = -1;newhead->next = NULL;struct ListNode* tail = newhead;//比较链表元素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;}else{tail->next = list2;}struct ListNode* ret = newhead->next;free(newhead);newhead = tail = NULL;return ret;
}

3.链表的中间节点

在这里插入图片描述

方法1

统计链表长度，计算出中间位置；再寻找中间位置

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

方法2

快慢指针法：一个指针一次走一步，一个指针一次走两步。当快指针尾空或者快指针的next为空，那么慢指针所指向的元素就是中间元素。
在这里插入图片描述

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

4.反转单链表

在这里插入图片描述

方法1

定义一个新的头节点，然后遍历链表，采取头插
在这里插入图片描述

struct ListNode* reverseList(struct ListNode* head) {struct ListNode* newHead = (struct ListNode*)malloc(sizeof(struct ListNode));newHead->val = -1;newHead->next = NULL;while(head){//先记录后继节点struct ListNode* next = head->next;//头插head->next = newHead->next;newHead->next = head;//节点后移head = next;}return newHead->next;
}

方法2

原地直接反转

  • 先记录当前节点的后继节点，以便节点后移
  • 当前节点指向其前驱节点
  • 前驱节点后移
  • 当前节点后移
  • prev即为反转后新的头

在这里插入图片描述

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

5.分割链表

在这里插入图片描述
思路：

  • 给定两个新的链表，一个放小于X的元素，一个放大于X的元素
  • 元素尾插至新链表
  • 将两个新链表相连

在这里插入图片描述

struct ListNode* partition(struct ListNode* head, int x){struct ListNode* minHead = (struct ListNode*)malloc(sizeof(struct ListNode));struct ListNode* maxHead = (struct ListNode*)malloc(sizeof(struct ListNode));struct ListNode* minTail = minHead;struct ListNode* maxTail = maxHead;struct ListNode* cur = head;while(cur){if(cur->val < x){minTail->next = cur;minTail = minTail->next;}else{maxTail->next = cur;maxTail = maxTail->next;}cur = cur->next;}//防止成环maxTail->next = NULL;minTail->next = maxHead->next;struct ListNode* ret = minHead->next;free(minHead);free(maxHead);return ret;
}

6.链表中的倒数第k个节点

在这里插入图片描述

方法1：

思路：倒数第k就是正数第n-k+1个（n为链表长度）
特殊情况：

  • k应该小于链表长度
  • k不能为0
  • 链表不能为空
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k) {struct ListNode* cur = pListHead;int len = 0;//求链表的长度while (cur){len++;cur = cur->next;}//特殊情况判断//1.k不能大于链表长度//2.k不能为0//3.链表不为空if (k > len || k == 0 || pListHead == NULL){return NULL;}//倒数第k个就是正数第n-k+1个int n = 1;len = len - k + 1;cur = pListHead;while (n != len){n++;cur = cur->next;}return cur;
}

方法2:

快慢指针：快指针先走k步，然后快慢一起走
在这里插入图片描述

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {struct ListNode* fast = pListHead;struct ListNode* slow = pListHead;//快指针先走k步while(k--){//fast不能走出链表（k符合）if(fast){fast = fast->next;}else {return NULL;}}while(fast){slow = slow->next;fast = fast->next;}return slow;
}

7.环形链表的约瑟夫问题

在这里插入图片描述
解题思路：

  • 构建环形链表，给每个节点编号
  • 逢m就删除节点，再从新报数

在这里插入图片描述

typedef struct ListNode  ListNode;//创建节点
ListNode* CreatNode(int x)
{ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));newnode->val = x;newnode->next = NULL;return newnode;
}//构建环
ListNode* CreatCircle(int n)
{ListNode* head = CreatNode(1);ListNode* tail = head;//连续创建节点for(int i=2; i<=n; i++){ListNode* newnode = CreatNode(i);//连接节点tail->next = newnode;tail = tail->next;}//成环tail->next = head;//返回尾节点的目的是：防止第一个元素就是要删除的元素return tail;
}int ysf(int n, int m ) {ListNode* prev = CreatCircle(n);ListNode* cur = prev->next;int count = 1;//有多个节点继续报数，直到剩下一个节点while(cur->next != cur){//逢m就删除if(count == m){prev->next = cur->next;free(cur);cur = prev->next;count = 1;}else {prev = cur;cur = cur->next;count++;}}return cur->val;
}

8.链表的回文结构

在这里插入图片描述
思路：从链表的中间节点逆置后半段，然后比较前半段与后半段是否相等。

  • 快慢指针找链表的中间节点
  • 从中间节点反转单链表
  • 节点比较

在这里插入图片描述
在这里插入图片描述

	//找中间节点ListNode* FindMid(ListNode* A){ListNode* fast = A;ListNode* slow = A;while(fast && fast->next){fast = fast->next->next;slow = slow->next;}return slow;   }//反转ListNode* Reverse(ListNode* mid){ListNode* cur = mid;ListNode* prev = NULL;ListNode* next = NULL;while(cur){next = cur->next;cur->next = prev;prev = cur;cur = next;}return prev;}bool chkPalindrome(ListNode* A) {ListNode* mid = FindMid(A);ListNode* midhead = Reverse(mid);while(midhead){if(A->val == midhead->val){A = A->next;midhead = midhead->next;}else {return false;}}return true;}

9.相交链表

在这里插入图片描述

方法1

将链表A中的每一个节点与链表B中的每一个节点比较，看是否相等。

  • 若相等，则返回相等的节点
  • 若所有节点都不相等，则链表不相交。
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {struct ListNode* curA = headA;struct ListNode* curB = headB;while(curA){curB = headB;while(curB){//若节点相等，直接返回相等节点if(curA == curB){return curA;}curB = curB->next;}curA = curA->next;}//A中每一个节点都与B比较完毕，仍无交点return NULL;
}

方法2：

分别计算两链表长度，长的先走长度差步，然后再一起走，判断是否相等。

  • 再求链表长度的同时，若两链表的最后一个节点相等，则二者一定相交
struct ListNode* getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {struct ListNode* curA = headA;struct ListNode* curB = headB;int lenA = 0;int lenB = 0;//先计算链表各自的长度，都少计算一个while(curA->next){lenA++;curA = curA->next;}while(curB->next){lenB++;curB = curB->next;}//若不相交，直接返回空if(curA != curB){return NULL;}//算长度差int  gap = abs(lenA - lenB);struct ListNode* longList = headA;struct ListNode* shortList = headB;if(lenA < lenB){longList = headB;shortList = headA;}//长的先走长度差步while(gap--){longList = longList->next;}//同时走，找交点while(longList && shortList){if(longList == shortList){return shortList;}longList = longList->next;shortList = shortList->next;}return NULL;
}

10.环形链表

在这里插入图片描述
思路：快慢指针。

  • 一个指针一次走一步，一个指针一次走两步
  • 若快指针走到了空，则不带环
  • 若快指针与慢指针相遇，则带环
bool hasCycle(struct ListNode *head) {struct ListNode * fast = head;struct ListNode * slow = head;while(fast && fast->next){slow = slow->next;fast = fast->next->next;if(slow == fast){return true;}}return false;
}

为什么这样可以呢?
在这里插入图片描述

为什么不是一个走1步一个走3步？一个走1步一个走4步？一个走1步一个走6步？…

在这里插入图片描述
在这里插入图片描述

若N为奇数，C-1也为奇数则永远追不上（存在这种情况吗？）

在这里插入图片描述
所以，一步两步走是最保险也是最简单的方式，不会错过。

11.环形链表Ⅱ

在这里插入图片描述
思路：快慢指针，找到二者的相遇点。再使用两指针，从相遇点和链表头开始走，二者相遇点就是入环点

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

原理

在这里插入图片描述

12.随机链表的复制

在这里插入图片描述
在这里插入图片描述
本题的难点在于random的指向难以找到
思路：

  • 在原链表每个节点的后面尾插一个新的节点
  • 根据原链表，找到新链表的random指向
  • 将新链表的节点与原链表分离，恢复原链表

第一步：连接新节点
在这里插入图片描述

第二步：搞清random指向
新链表random就是原链表random的next!!!
在这里插入图片描述
第三步：将新链表从原链表上摘下来
在这里插入图片描述

struct Node* copyRandomList(struct Node* head) {struct Node* cur = head;//插入新节点while(cur){struct Node* newnode = (struct Node*)malloc(sizeof(struct Node));//连接新节点newnode->val = cur->val;newnode->next = cur->next;cur->next = newnode;//原链表后移cur = cur->next->next;}//randomcur = head;while(cur){struct Node* newnode = cur->next;if(cur->random == NULL){newnode->random = NULL;}else{newnode->random = cur->random->next;}cur = cur->next->next;}//摘新链表struct Node* newhead = (struct Node*)malloc(sizeof(struct Node));newhead->next = NULL;newhead->random = NULL;struct Node* tail = newhead;cur = head;while(cur){//尾插新链表struct Node* newnode = cur->next;tail->next = newnode;tail = tail->next;//恢复原链表cur->next = newnode->next;cur = cur->next;}return newhead->next;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/465800.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

HCIA-HarmonyOS设备开发认证V2.0-3.2.轻量系统内核基础-软件定时器

HCIA-HarmonyOS设备开发认证V2.0-3.2.轻量系统内核基础-软件定时器

目录 一、软件定时器基本概念二、软件定时器运行机制三、软件定时器状态四、软件定时器模式五、软件定时器开发流程六、软件定时器使用说明七、软件定时器接口八、代码分析&#xff08;待续...&#xff09; 一、软件定时器基本概念 软件定时器&#xff0c;是基于系统 Tick 时钟…
阅读更多...
Win32 控制台绘图2

Win32 控制台绘图2

之前已经了解在控制台可以调用Win32 api绘图&#xff1b;下面继续加深一下此概念&#xff1b; #include <stdio.h> #include <stdlib.h> #include <windows.h>HWND WINAPI GetConsoleWindow();int main(int argc, char *argv[]) {HWND hwnd; HDC hdc; HPE…
阅读更多...
VUE学习——事件处理

VUE学习——事件处理

事件分为内联事件和方法事件。 我们可以使用【v-on】&#xff08;简写&#xff1a;&#xff09;来处理。 内联 <button v-on:click"count">按钮</button><button click"count">按钮</button><p>{{ count }}</p>方法
阅读更多...
ZOJ 3537 Cake 【区间DP + 凸多边形三角剖分】

ZOJ 3537 Cake 【区间DP + 凸多边形三角剖分】

Cake 题意 给定平面坐标上的 n n n 个点&#xff0c;如果是凸多边形的话&#xff0c;就用最少的花费把这个多边形剖分成若干个三角形&#xff0c;剖分的线段端点只能是原多边形的顶点&#xff0c;一条线段的花费为&#xff1a; ∣ x i x j ∣ ∣ y i y j ∣ m o d p |x_i…
阅读更多...
鸿蒙系统进一步学习（一）：学习资料总结，少走弯路

鸿蒙系统进一步学习（一）：学习资料总结，少走弯路

随着鸿蒙Next的计划越来越近&#xff0c;笔者之前的鸿蒙系统扫盲系列中&#xff0c;有很多朋友给我留言&#xff0c;不同的角度的问了一些问题&#xff0c;我明显感觉到一点&#xff0c;那就是许多人参与鸿蒙开发&#xff0c;但是又不知道从哪里下手&#xff0c;因为资料太多&a…
阅读更多...
Unity学习笔记（零基础到就业）｜Chapter04:C#篇补充到Unity篇过渡

Unity学习笔记（零基础到就业）｜Chapter04:C#篇补充到Unity篇过渡

Unity学习笔记&#xff08;零基础到就业&#xff09;&#xff5c;Chapter02:C#篇补充到Unity篇过渡 前言C#总结补充1.值类型和引用类型有什么区别&#xff0c;他们在值的传递上分别有怎样的特性2.string是引用类型&#xff0c;但是他对外表现出值类型的特性&#xff0c;为什么&…
阅读更多...
推荐系统｜行为序列_用户行为序列建模、Din模型和SIM模型

推荐系统｜行为序列_用户行为序列建模、Din模型和SIM模型

文章目录 用户行为序列建模Din模型Din模型的缺点 用户行为序列建模 物品ID通过Embedding将会得到一个向量&#xff0c;性质差不多的向量在空间中也会处于差不多的位置&#xff0c;可以用取平均方式得到一个综合所有向量的向量。 取平均后可以作为代表用户的一个特征。 以上的…
阅读更多...
性能最接近 GPT4，开源AI模型 “泄露”

性能最接近 GPT4，开源AI模型 “泄露”

近期开源 AI 社区发生了一场大事件&#xff0c;一位用户在 HuggingFace 平台上传了一系列文件&#xff0c;包含一个看似新的开源大型语言模型“miqu-1-70b”。这一模型被认为是最接近 OpenAI 的 GPT-4&#xff0c;引发了广泛关注和猜测。 不少用户则在社交平台 X &#xff08;…
阅读更多...
bugku 1

bugku 1

Flask_FileUpload 文件上传 先随便传个一句话木马 看看回显 果然不符合规定 而且发现改成图片什么的都不行 查看页面源代码&#xff0c;发现提示 那应该就要用python命令才行 试试ls 类型要改成图片 cat /flag 好像需要密码 bp爆破 根据提示&#xff0c;我们先抓包 爆破 …
阅读更多...
麒麟操作系统选型适配：经验与策略分享

麒麟操作系统选型适配：经验与策略分享

一、麒麟操作系统概况 麒麟V10是一款商业版本服务器操作系统&#xff0c;其作为承载业务系统的基础底座&#xff0c;能满足大部分企业的产品需求&#xff0c;各类软硬件适配也都较好。麒麟V10的SP1/SP2/SP3版本内核都是基于OpenEuler 20.03 LTS研发的&#xff0c;其支持X86、A…
阅读更多...
人工智能如何彻底改变身份欺诈

人工智能如何彻底改变身份欺诈

据 AuthenticID 称&#xff0c;近一半的企业报告合成身份欺诈有所增加&#xff0c;而生物识别欺骗和伪造 ID 欺诈尝试也有所增加。 在当今的数字化存在中&#xff0c;消费者和企业都面临着新的挑战&#xff0c;从考虑数字身份的影响到应对生成人工智能等新工具的使用和流行。与…
阅读更多...
FL Studio版本升级-FL Studio怎么升级-FL Studio升级方案

FL Studio版本升级-FL Studio怎么升级-FL Studio升级方案

已经是新年2024年了&#xff0c;但是但是依然有很多朋友还在用FL Studio12又或者FL Studio20&#xff0c;今天这篇文章教大家如何升级FL Studio21 FL Studio 21是Image Line公司开发的音乐编曲软件&#xff0c;除了软件以外&#xff0c;我们还提供了FL Studio的升级服务&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023