24. 两两交换链表中的节点
用虚拟头结点,这样会方便很多。
本题链表操作就比较复杂了,建议大家先看视频,视频里讲解了注意事项,为什么需要temp保存临时节点。
题目链接/文章讲解/视频讲解: 代码随想录
题目:给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例 1:
输入:head = [1,2,3,4] 输出:[2,1,4,3]
示例 2:
输入:head = [] 输出:[]
示例 3:
输入:head = [1] 输出:[1]
这里需要设置一个虚拟头节点指向head,为了不改变虚拟头结点的位置,我们增加了一个cur,方便移动,cur->next=head,假设交换节点1和节点2的位置,需要先使得cur指向节点2,再使得节点2指向节点1,因此有cur->next = cur->next->next,cur->next->next = cur->next。但实际上,当执行cur->next = cur->next->next时,就已经改变cur的下一个指向了,实际上cur->next->next是节点3,所以没办法使得节点2指向节点3,因此要增加一个变量temp1保存原来节点1的位置,temp1=cur->next。
同理,当想要节点1指向节点3时,节点3的位置也已经被改变了,所以要先增加变量temp=cur->next->next->next,保存节点3的原始位置
之后将cur后移两位进行下一对相邻数字的交换
具体代码:
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummy = new ListNode(0);
dummy->next = head;
ListNode* cur = dummy;
while (cur->next && cur->next->next){
ListNode* temp = cur->next->next->next;
ListNode* temp1 = cur->next;
cur->next = cur->next->next;
cur->next->next = temp1;
cur->next->next->next = temp;
cur = cur->next->next;
}
return dummy->next;
}
};
19.删除链表的倒数第N个节点
双指针的操作,要注意,删除第N个节点,那么我们当前遍历的指针一定要指向第N个节点的前一个节点,建议先看视频。
题目链接/文章讲解/视频讲解:代码随想录
给你一个链表,删除链表的倒数第 n
个结点,并且返回链表的头结点。
示例 1:
输入:head = [1,2,3,4,5], n = 2 输出:[1,2,3,5]
示例 2:
输入:head = [1], n = 1 输出:[]
示例 3:
输入:head = [1,2], n = 1 输出:[1]
先来回顾删除链表节点的操作,令前一个节点指向后面的节点。
这里要删除倒数第N个节点,需要借助双指针fast和slow。fast从head出发,先移动N步,然后slow和fast同时移动,当fast移动到尾部,slow刚好移动到删除的位置。但是要注意,如果删除第N个节点,那么我们当前遍历的指针一定要指向第N个节点的前一个节点,这样可以直接通过改变指针的指向来删除第N个节点,slow->next = slow->next->next。
具体代码:
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummy = new ListNode(0);
dummy->next = head;
ListNode* fast = dummy;
ListNode* slow = dummy;
for (int i = 0; i < n+1; i++){
fast = fast->next;
}
while(fast){
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
return dummy->next;
}
};
面试题 02.07. 链表相交
大家注意 数值相同,不代表指针相同。
给你两个单链表的头节点 headA
和 headB
,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null
。
图示两个链表在节点 c1
开始相交:
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
示例 1:
输入: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 个节点。
示例 2:
输入: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 个节点。
首先需要将链表A和链表B的尾部对齐,所以必须求出链表A和链表B的长度差,求链表的长度可以通过cur的移动来实现。另外,我们需要知道哪一个链表的长度更长,因此这里直接设置链表A的长度更长,在实际不符合时,通过swap()函数进行交换,最后保证长度差为正数
ListNode* curA = headA;
ListNode* curB = headB;
int lenA = 0, lenB = 0;
int l;
while(curA){
lenA++;
curA = curA->next;
}
while(curB){
lenB++;
curB = curB->next;
}
if (lenA > lenB){
l = lenA - lenB;
}else{
swap(lenA, lenB);
l = lenA - lenB;
swap(headA, headB);
}
求出长度差l之后,将长度较长的链表A的curA指针移动l位,之后curA和curB同时往后遍历。直到二者节点相等,若不存在节点相等的位置,则返回null
具体代码
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* curA = headA;
ListNode* curB = headB;
int lenA = 0, lenB = 0;
int l;
while(curA){
lenA++;
curA = curA->next;
}
while(curB){
lenB++;
curB = curB->next;
}
if (lenA > lenB){
l = lenA - lenB;
}else{
swap(lenA, lenB);
l = lenA - lenB;
swap(headA, headB);
}
curA = headA;//curA移动到头节点的位置
curB = headB;
for(int i = 0; i < l; i++){
curA = curA->next;
}
while(curA){
if(curA == curB){
return curA;
}
curA = curA->next;
curB = curB->next;
}
return NULL;
}
};
142.环形链表II
算是链表比较有难度的题目,需要多花点时间理解 确定环和找环入口,建议先看视频。
题目链接/文章讲解/视频讲解:代码随想录
给定一个链表的头节点 head
,返回链表开始入环的第一个节点。 如果链表无环,则返回 null
。
如果链表中有某个节点,可以通过连续跟踪 next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos
是 -1
,则在该链表中没有环。注意:pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1:
输入:head = [3,2,0,-4], pos = 1 输出:返回索引为 1 的链表节点 解释:链表中有一个环,其尾部连接到第二个节点。
示例 2:
输入:head = [1,2], pos = 0 输出:返回索引为 0 的链表节点 解释:链表中有一个环,其尾部连接到第一个节点。
示例 3:
输入:head = [1], pos = -1 输出:返回 null 解释:链表中没有环。
分别定义快慢指针fast和slow,从头结点出发,fast每次移动两个节点,slow移动一个节点,如果fast和slow相遇,说明链表中存在环。
首先fast一定比slow先进入环,所以他们相遇的位置只能在环里。而fast每次移动两个节点,速度快,是追赶slow的过程,所以一定能够相遇。
假设从头结点到环形入口节点的节点数为x,环形入口节点到二者相遇节点的节点数为y,相遇节点到入口节点的节点数为z,所以二者相遇时,slow走过的节点数为x+y,fast走过的节点数为x+y+n(y+z),n(y+z)表示循环了n圈,
因为fast每次移动两个节点,slow移动一个,所以相遇时,fast走过的节点是slow的两倍,有
(x + y) * 2 = x + y + n (y + z)
得到x = (n - 1) (y + z) + z,当n =1时,x=z。
因此我们只需要在遍历时,找到fast和slow相遇的节点,然后定义index=head,index1=fast,开始遍历,直到index=index1,就能找到环形入口的节点
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast && fast->next){
slow = slow->next;
fast = fast->next->next;
if (slow == fast){
ListNode* index1 = fast;
ListNode* index2 = head;
while(index1 != index2){
index1 = index1->next;
index2 = index2->next;
}
return index2;
}
}
return NULL;
}
};