第二章 链表part02
- 24. 两两交换链表中的节点
- 19.删除链表的倒数第N个节点
- 面试题 02.07. 链表相交
- 142.环形链表II
- 总结
24. 两两交换链表中的节点
用虚拟头结点,这样会方便很多。
本题链表操作就比较复杂了,建议大家先看视频,视频里我讲解了注意事项,为什么需要temp保存临时节点。
/**
* 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) {
if(head==nullptr||head->next==nullptr)
return head;
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* pre=dummyHead;
ListNode* cur1=dummyHead->next;
ListNode* cur2=head->next;
ListNode* temp1 = cur2->next;
while(cur1!=nullptr&&cur2!=nullptr){
pre->next=cur2;
temp1 = cur2->next;
cur2->next=cur1;
cur1->next=temp1;
pre=cur1;
cur1=cur1->next;
if(cur1!=nullptr)
cur2=cur1->next;
}
ListNode* result = dummyHead->next;
delete dummyHead;
return result;
}
};
这幅图还是比较好理解的,开始的时候先判断下
返回值的时候,以为直接返回头节点,看了下代码随想录的代码,还要删除自己加入的虚拟头节点,遂稍微修改下。另外要注意下最后判断if (cur1 != nullptr) { cur2 = cur1->next; }
题目链接/文章讲解/视频讲解: 代码随想录
19.删除链表的倒数第N个节点
双指针的操作,要注意,删除第N个节点,那么我们当前遍历的指针一定要指向 第N个节点的前一个节点,建议先看视频。
题目链接/文章讲解/视频讲解:代码随想录
-
定义fast指针和slow指针,初始值为虚拟头结点,如图:
-
fast首先走n + 1步 ,为什么是n+1呢,因为只有这样同时移动的时候slow才能指向删除节点的上一个节点(方便做删除操作),如图:
-
fast和slow同时移动,直到fast指向末尾,如题:
-
删除slow指向的下一个节点,如图:
原本想着先遍历一遍,再遍历一遍,感觉这种思路有点麻烦,看着代码里的过程,恍然大悟,有道理呢。把两次遍历搞到一起,这种快慢指针的思想真的很好呢。
不过,还是要注意,不能返回头指针,因为有可能在程序运行时候,头指针就是被删除的点,所以要新设一个头指针。
/**
* 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* dummyNode=new ListNode(0);
dummyNode->next=head;
ListNode* slow=dummyNode;
ListNode* fast=dummyNode;
while(n--){
fast=fast->next;
if(fast==nullptr)
{
delete dummyNode;
return head;}
}
fast=fast->next;
while(fast!=nullptr)
{
fast=fast->next;
slow=slow->next;
}
ListNode*temp=slow->next;
slow->next=slow->next->next;
delete temp;
ListNode* newHead = dummyNode->next;
delete dummyNode;
return newHead;
}
};
面试题 02.07. 链表相交
本题没有视频讲解,大家注意 数值相同,不代表指针相同。
题目链接/文章讲解:代码随想录
简单来说,就是求两个链表交点节点的指针。 这里同学们要注意,交点不是数值相等,而是指针相等。
为了方便举例,假设节点元素数值相等,则节点指针相等。
看如下两个链表,目前curA指向链表A的头结点,curB指向链表B的头结点:
我们求出两个链表的长度,并求出两个链表长度的差值,然后让curA移动到,和curB 末尾对齐的位置,如图:
此时我们就可以比较curA和curB是否相同,如果不相同,同时向后移动curA和curB,如果遇到curA == curB,则找到交点。
否则循环退出返回空指针。
这题思路还是比较简答的,主要是编写代码并不轻松,中间出了很多问题,比如大和小绕了下,没有考虑头节点是空的情况。
/**
* 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)
{
int sizeA=0;
int sizeB=0;
ListNode *big=headA;//先假设A更长,原本想着long,但是long是变量类型,遂直接big
ListNode *small=headB;//
while(big!=nullptr)
{
big=big->next;
sizeA++;
}
while(small!=nullptr)
{
small=small->next;
sizeB++;
}
int sizeBig=sizeA;
int sizeSmall=sizeB;
big=headA;
small=headB;
if(sizeB>sizeA)
{
big=headB;
small=headA;
sizeSmall=sizeA;
sizeBig=sizeB;
}
int gap=sizeBig-sizeSmall;
while(gap--)
{
big = big->next;
}
while(big!=nullptr)
{
if(big==small)
return big;
big=big->next;
small=small->next;
}
return nullptr;
}
};
142.环形链表II
算是链表比较有难度的题目,需要多花点时间理解 确定环和找环入口,建议先看视频。
题目链接/文章讲解/视频讲解:代码随想录
可以使用快慢指针法,分别定义 fast 和 slow 指针,从头结点出发,fast指针每次移动两个节点,slow指针每次移动一个节点,如果 fast 和 slow指针在途中相遇 ,说明这个链表有环。
为什么fast 走两个节点,slow走一个节点,有环的话,一定会在环内相遇呢,而不是永远的错开呢
首先第一点:fast指针一定先进入环中,如果fast指针和slow指针相遇的话,一定是在环中相遇,这是毋庸置疑的。
那么来看一下,为什么fast指针和slow指针一定会相遇呢?
不要背误解快指针是慢指针两倍的速度,而是快指针比慢指针快1,所以当在环里的时候,快指针在一步步追赶慢指针,总会追赶上的。
如果有环,如何找到这个环的入口
此时已经可以判断链表是否有环了,那么接下来要找这个环的入口了。
假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示:
那么相遇时: slow指针走过的节点数为: x + y
, fast指针走过的节点数:x + y + n (y + z)
,n为fast指针在环内走了n圈才遇到slow指针, (y+z)为 一圈内节点的个数A。
因为fast指针是一步走两个节点,slow指针一步走一个节点, 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2:
(x + y) * 2 = x + y + n (y + z)
两边消掉一个(x+y): x + y = n (y + z)
因为要找环形的入口,那么要求的是x,因为x表示 头结点到 环形入口节点的的距离。
所以要求x ,将x单独放在左面:x = n (y + z) - y
,
再从n(y+z)中提出一个 (y+z)来,整理公式之后为如下公式:x = (n - 1) (y + z) + z
注意这里n一定是大于等于1的,因为 fast指针至少要多走一圈才能相遇slow指针。
这个公式说明什么呢?
先拿n为1的情况来举例,意味着fast指针在环形里转了一圈之后,就遇到了 slow指针了。
当 n为1的时候,公式就化解为 x = z
,
这就意味着,从头结点出发一个指针,从相遇节点 也出发一个指针,这两个指针每次只走一个节点, 那么当这两个指针相遇的时候就是 环形入口的节点。
也就是在相遇节点处,定义一个指针index1,在头结点处定一个指针index2。
让index1和index2同时移动,每次移动一个节点, 那么他们相遇的地方就是 环形入口的节点。
其实,可以先从假设快指针只多跑一圈的情况下考虑(快指针一定至少多跑了一圈,不然追不上慢指针)。那么快指针跑的还是慢指针的两倍,慢指针走了x,y。快指针走了x,y,y+z(一圈),这俩是两倍x=z,
动画如下:
那么 n如果大于1是什么情况呢,就是fast指针在环形转n圈之后才遇到 slow指针。
其实这种情况和n为1的时候 效果是一样的,一样可以通过这个方法找到 环形的入口节点,只不过,index1 指针在环里 多转了(n-1)圈,然后再遇到index2,相遇点依然是环形的入口节点。
为什么第一次在环中相遇,slow的 步数 是 x+y 而不是 x + 若干环的长度 + y 呢?
其实也很简单,想想也知道,快指针的速度是慢指针的速度的两倍,你和你的朋友一起出发去绕着公园转圈,他骑自行车,你走路,速度是你两倍,那么只要想想就知道,你肯定在公园走不了一圈,你俩就能相遇了。
写代码的时候,发现一直报错,后来发现是while(fast!=slow)循环语句的问题,后改成do-while语句,这才通过,自己改代码的能力还是需要继续提升呢。耽误了好长时间。
/**
* 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) {
if(head==nullptr||head->next==nullptr)
return nullptr;
ListNode *fast=head;
ListNode *slow=head;
do{
slow=slow->next;
if(fast==nullptr||fast->next==nullptr)
return nullptr;
else
fast=fast->next->next;
}while(fast!=slow);
ListNode *index1=fast;
ListNode *index2=head;
while(index1!=index2)
{
index1 = index1->next;
index2 = index2->next;
}
return index1;
}
};
总结
一般涉及到 增删改操作,用虚拟头结点都会方便很多, 如果只能查的话,用不用虚拟头结点都差不多。因为增删改的话很容易涉及到头节点,就很尴尬,如果只是查找的话,就不用担心呢。
感觉改代码的能力还是需要继续提升。这两天的学习,对于链表了解很多,还不错,一步一个脚印吧。