24.两两交换链表中的节点
题目描述:
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例一:
输入:head = [1,2,3,4]
输出:[2,1,4,3]
示例二:
输入:head = [1]
输出:[1]
提示:
链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100
解题思路:
- 关键词提取:交换两个相邻节点
- 暴力解法:
- 采用虚拟头节点的方式去操作链表
- 必须是两个相邻的节点,也就是单个节点不需要操作
- 需要搞清楚的是节点之间的关系,最好的方式还是画图来解决,否则节点的指针传递容易出错
- 由于需要交换两个节点,因此,需要将两个节点的next指针都储存起来,便于操作。节点t1储存节点1的next指针,节点t2储存节点2的next指针
- 节点cur储存虚拟头节点,节点pre储存节点cur的next指针,即节点1
- 让节点cur指向节点t1
- 让节点t1指向节点1,即节点pre
- 让节点1指向节点t2,即节点pre指向节点t2
- 一次节点交换就完成,若需要执行下一次节点交换,则需要将节点cur指向节点1,即节点pre
- 需要注意的是,交换发生的条件是节点1和节点2都不为空
代码如下:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
// 建立虚拟头节点
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
// 建立一个遍历的虚拟头节点
ListNode* curNode = dummyHead;
while(curNode->next != nullptr && curNode->next->next != nullptr) {
// 建立一个临时节点存储节点1
ListNode* preNode = curNode->next;
// 建立两个临时节点存储节点1和节点2的next指针
ListNode* tmp1Node = preNode->next;
ListNode* tmp2Node = preNode->next->next;
// 虚拟头节点指向节点1的next指针
curNode->next = tmp1Node;
// 节点2指向节点1
tmp1Node->next = preNode;
// 节点1指向节点2的next指针
preNode->next = tmp2Node;
// 移动虚拟头节点,至节点1
curNode = preNode;
}
// 返回链表的头节点
return dummyHead->next;
}
};
总结:
-
二刷,还是没有读懂题目,导致把题目想复杂,难以落笔,只好去看看题解。
1)难点一:两个节点交换,有三个next指针,容易指错对象,也容易导致程序bug。
2)难点二:两个节点交换的循环,退出条件是什么,这个很容易导致程序bug,也很难找出来原因。 -
代码随想录中提到的思路,让我二刷的时候清晰许多。
1)虚拟头节点的含义和用法。carl哥都讲解得很清晰。详见视频[https://www.bilibili.com/video/BV18B4y1s7R9/]:
2)画图。将各个节点以及节点的next指针都画出来。将储存next指针的节点也画出来。第一步取消掉next指针的指向,采用临时节点存起来。第二步再摆放节点位置。第三步就重新画next指针的指向。
3)尽管我多用了一个节点,但是这个是我思考之后,自己摸索出来的一个理解以后的方式。所以我没有按照carl哥的方式去解这道题。对于多用的pre节点,我的解释没有那么清晰,因为我对节点的理解还没有那么娴熟,也希望大家看完以后可以给我反馈,感谢。
19.删除链表的倒数第N个节点
题目描述:
给你一个链表,删除链表的倒数第 n
个结点,并且返回链表的头结点。
示例一:
输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
示例二:
输入:head = [1,2], n = 1
输出:[1]
提示:
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
解题思路:
-
关键词提取:删除、倒数第N个
-
暴力解法:
- 遍历一遍链表,记录节点个数size,由0开始计数
- 第二次再遍历链表,找到链表节点下标size-n-1,即待删除节点的前一个节点
- 采用临时节点存储下一个节点的next指针
- 当前节点指向临时节点
- 删除下一个节点
-
双指针法:
- 新建两个指针,左指针和右指针
- 倒数第N个数,假定N是两个指针之间的差值
- 当右指针指向最后一个节点时,左指针指向的节点,就是待删除节点的前一个节点
- 初始状态下,右指针指向头节点,左指针指向虚拟头节点
- 右指针开始移动,当右指针与左指针的差值超过n时,同步移动左指针
- 右指针移动到最后一个节点时,执行删除动作
- 采用临时节点储存左指针的next指针(即删除节点)
- 左指针指向临时节点的next指针
- 删除临时节点
双指针法代码如下:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
// 建立虚拟头节点
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
// 建立左右指针
int right = 0;
ListNode* curNode = dummyHead->next;
int left = -1;
ListNode* preNode = dummyHead;
// 遍历链表,直至右指针指向最后一个元素
while(curNode != nullptr && curNode->next != nullptr) {
// 右指针移动
curNode = curNode->next;
right++;
// 若右指针与左指针的距离超过N,左指针同步移动
if(right - left > n) {
left++;
preNode = preNode->next;
}
}
// 删除指定节点
ListNode* tmpNode = preNode->next;
preNode->next = preNode->next->next;
// preNode->next->next = nullptr;
delete(tmpNode);
// 返回链表头节点
return dummyHead->next;
}
};
总结:
-
第一次做的时候,会采用暴力解法。
1)单向链表跟队列有点像。定位倒数第N个元素,可以做两次遍历解决。2)简单题就是删除第N个元素,只需要一次遍历即可。
-
代码随想录刷题中采用的是双指针法,稍微思考一下,可以联想到。
1)两次遍历,即两个for循环,可以想办法去降维,多用一个变量,左右指针从左右向中间靠拢,找到指定元素。
2)发现这道题跟滑动窗口有点像,左右指针构成一个窗口,窗口中是N+1个数,需要的是将最后一个节点囊括进来的窗口。取窗口的左边界辅助做删除节点的动作。
3)发现还能用栈去做,压栈、出栈,逻辑上有点类似。可以先将链表全部入栈,然后弹出N个元素,取最后一个弹出的元素,辅助做删除动作。
160.链表相交
题目描述:
给你两个单链表的头节点 headA
和 headB
,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null
。
示例一:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at '8'
解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。
在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
示例二:
输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出:Intersected at '2'
解释:相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [0,9,1,2,4],链表 B 为 [3,2,4]。
在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。
提示:
listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点,intersectVal 为 0
如果 listA 和 listB 有交点,intersectVal == listA[skipA + 1] == listB[skipB + 1]
解题思路:
- 关键词提取:单链表、相交、起始节点
- 暴力法:两个for循环,一个负责遍历链表A,另一个负责嵌套遍历链表B,判断是否会出现链表A的某个节点与链表B的某个节点相同
- 暴力法优化:
- 关注相交节点的含义,是指链表A和链表B在起始相交节点后的节点长度与值都一致
- 找到链表的最后一个节点,看两个节点是否相等,即可判断是否有相交
- 由此可发现,相交的话,会跟最后一个节点有关系,那么有一个切入点是将两个链表的末端对齐,可以从后往前找,找到起始相交节点
- 第一步是计算出两个链表的长度
- 第二步是将两个链表的末端对齐,根据长度做差,遍历长链表,移动至差值位置,目的是让两个链表同步从头遍历
- 第三步是同步遍历两个链表,检索是否有相同的节点
代码如下:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* dummyAHead = new ListNode(0);
dummyAHead->next = headA;
ListNode* dummyBHead = new ListNode(0);
dummyBHead->next = headB;
ListNode* curANode = dummyAHead->next;
ListNode* curBNode = dummyBHead->next;
int lenA = 0;
int lenB = 0;
// 检索链表A的长度
while(curANode != NULL && curANode->next != NULL) {
curANode = curANode->next;
lenA++;
}
// 检索链表B的长度
while(curBNode != NULL && curBNode->next != NULL) {
curBNode = curBNode->next;
lenB++;
}
// 假如两个链表的最后一个节点不相等,意味着没有交点,若相等,则需要往前找到相交的起始位置
if(curANode != curBNode) {
return NULL;
}
// 定义两个链表的长度差值
int gap = 0;
// 将长度较长的链表定义为链表A
if(lenA >= lenB) {
curANode = dummyAHead->next;
curBNode = dummyBHead->next;
gap = lenA - lenB;
}
else {
curANode = dummyBHead->next;
curBNode = dummyAHead->next;
gap = lenB - lenA;
}
// 链表A的遍历指针移动至gap值位置
// 链表A和链表B的末尾位置对齐
while(gap > 0) {
curANode = curANode->next;
gap--;
}
// 链表节点同时往后移动,找到相交点即可
while(curANode != NULL) {
if(curANode == curBNode) {
return curANode;
}
curANode = curANode->next;
curBNode = curBNode->next;
}
return NULL;
}
};
总结:
-
第一次做,还是老规矩,暴力解法。
1)难点是对于相交节点的定义不够清晰。会被误导成节点的值相等,导致无从下手。2)按照定义,就是两个嵌套的for循环,去找相同的节点。
-
代码随想录提供一个新的思路,就是针对相交,对暴力法做优化。
1)针对相交的这个定义,提供一个新的思路,就是将两个链表末端对齐,再从头开始同步遍历两个链表,直至找到相交的节点。
2)原理就是:在节点相交以后,之后的节点,都是一样的节点,也就是长度和值都相同。
142.环形链表II
题目描述:
给定一个链表的头节点 head
,返回链表开始入环的第一个节点。 如果链表无环,则返回 null
。
如果链表中有某个节点,可以通过连续跟踪 next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos
是 -1
,则在该链表中没有环。注意:pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例一:
输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。
示例二:
输入:head = [1,2], pos = 0
输出:返回索引为 0 的链表节点
解释:链表中有一个环,其尾部连接到第一个节点。
提示:
链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引
解题思路:
- 关键词提取:某个节点可以再次到达(成环)
- 双指针法:
- 新建两个指针,快指针和慢指针
- 有一个算法原理是快慢指针,假如是成环的,那么一快一慢,快的那个在一定时间后,一定能追上慢的那个,也就是相遇
- 在确认快指针没有指向链表末尾,也就是不成环的情况下,快指针每次移动两个节点,而慢指针每次移动一个节点
- 在快慢指针相遇后,只能确认是成环,还需要找到入口
- 新建两个指针,指针1和指针2
- 有个数学计算结果是,在相遇时,采用指针1指向慢指针,采用指针2指向头指针,每次两个指针都移动一个节点,两个指针一定能相遇,这时,相遇点就是入口
快慢指针法代码如下:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
// 分别定义快指针、慢指针
ListNode* fast = head;
ListNode* slow = head;
// 快指针走得快,以快指针的状态来判断是否为空
while(fast != NULL && fast->next != NULL) {
// 龟兔赛跑,一快一慢,终究会遇到
slow = slow->next;
fast = fast->next->next;
// 遇到之后,需要找环的入口
if(slow == fast) {
// 一步一步,有差值,终究会遇到
// 从头指针开始,与遇到的节点开始,循环滚动,总会遇到
ListNode* index1 = head;
ListNode* index2 = slow;
while(index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
return index1;
}
}
return NULL;
}
};
总结:
- 第一次做的时候,我做不出来,没什么思路。
- 代码随想录刷题中采用的是快慢指针法。
1)第一次看到的时候,还是蛮难去接受这个数学原理的,就是也不能算作算法的一种,但是的确又是一种很好的方法。通过两次刷题,将这个方法记住,这是我的现状。
2)官方题解会提供哈希表的方式,想了一下,的确,在检索重复元素方面,哈希表的确是个很好的方法。这点没有思考过,需要加强。
3)快慢指针,龟兔赛跑,找到相遇点,这个我可以理解,但是找到入口的这个部份,我理解得不是很好,为什么这个相遇,就是入口呢。希望可以有大佬给我提一些思路,感谢。