24. 两两交换链表中的节点
一、题目详情
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例 1:
输入:head = [1,2,3,4] 输出:[2,1,4,3]
示例 2:
输入:head = [] 输出:[]
示例 3:
输入:head = [1] 输出:[1]
提示:
- 链表中节点的数目在范围
[0, 100]
内 0 <= Node.val <= 100
二、解题思路
关键在于拆链子的顺序,拆不对可能就会掉链子。
首先是插入一个虚拟头结点。然后定位到要交换的两个结点的前一个结点,毕竟这个结点的next也要修改。这里直接是用Node1和Node2存好要交换的结点cur->next和cur->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* swapPairs(ListNode* head) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* cur = dummyHead;
while(cur->next != nullptr && cur->next->next != nullptr){
ListNode* Node1 = cur->next;
ListNode* Node2 = cur->next->next;
cur->next = Node2;
Node1->next = Node2->next;
Node2->next = Node1;
cur = Node1;
}
return dummyHead->next;
}
};
19.删除链表的倒数第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]
二、解题思路
先统计链表有多少个结点,然后将倒数的数转化为正数下去第几个,顺着链子往下找,进行删除。要注意找到的是要删除的结点的前一个结点开始进行的删除操作。这里加了虚拟头结点。注意算术关系。
三、解题代码
/**
* 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;
ListNode* ptr = dummyHead->next;
//计算长度
int count = 0;//加上虚拟头的总结点个数
while(ptr){
count++;
ptr = ptr->next;
}
count = count - n;
ptr = dummyHead;
while(count--){
ptr=ptr->next;
}
ListNode* del = ptr->next;
ptr->next = del->next;
delete del;
return dummyHead->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 个节点。
示例 3:
输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 输出:null 解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。 由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。 这两个链表不相交,因此返回 null 。
提示:
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]
进阶:你能否设计一个时间复杂度 O(n)
、仅用 O(1)
内存的解决方案?
二、解题思路
用的哈希集合进行地址记忆。先把其中一个链表出现过的结点的地址都存在一个set集合里。然后用另一个链表去判断其中的结点也没有出现在set集合里,如果有即有相交,第一个出现在set里面的就是要返回的地址。如果另一条链表的所有结点地址都没有出现在set里,则没有相交。
三、解题代码
/**
* 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) {
unordered_set<ListNode*>visited;
ListNode* ptr = headA;
//记录headA有点地址
while(ptr){
visited.insert(ptr);
ptr = ptr->next;
}
//看看headB链的地址从什么时候开始存在于set中
ptr = headB;
while(ptr){
if(visited.count(ptr)){
return ptr;
}
ptr = ptr->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 解释:链表中没有环。
提示:
- 链表中节点的数目范围在范围
[0, 104]
内 -105 <= Node.val <= 105
pos
的值为-1
或者链表中的一个有效索引
进阶:你是否可以使用 O(1)
空间解决此题?
二、解题思路
第一反应也是哈希集合……看了题解后:头好痒,要长脑子了!记录学习一下快慢指针的写法。快慢指针跟数学有关,虽然我自己从0想不到……但看懂了QWQ。
双指针的第一次相遇:
设两指针 fast,slow 指向链表头部 head 。
令 fast 每轮走 2步,slow 每轮走 1 步。
执行以上两步后,可能出现两种结果:第一种结果: fast 指针走过链表末端,说明链表无环,此时直接返回 null。
如果链表存在环,则双指针一定会相遇。因为每走 111 轮,fast 与 slow 的间距 +1+1+1,fast 一定会追上 slow 。
第二种结果: 当fast == slow时, 两指针在环中第一次相遇。下面分析此时 fast 与 slow 走过的步数关系:
fast 走的步数是 slow 步数的 2倍,
fast 比 slow 多走了 n 个环的长度,双指针都走过 a步,然后在环内绕圈直到重合,重合时 fast 比 slow 多走 环的长度整数倍 。
将以上两式相减得到 f=2nb,s=nb,即 fast 和 slow 指针分别走了 2n,n 个环的周长。如果让指针从链表头部一直向前走并统计步数k,那么所有 走到链表入口节点时的步数 是:k=a+nb,即先走 a 步到入口节点,之后每绕 1 圈环( b 步)都会再次到入口节点。而目前 slow 指针走了 nb 步。因此,我们只要想办法让 slow 再走 a 步停下来,就可以到环的入口。
依然是使用双指针法。考虑构建一个指针,此指针需要有以下性质:此指针和 slow 一起向前走 a 步后,两者在入口节点重合。那么从哪里走到入口节点需要 a步?答案是链表头节点。
作者:Krahets
链接:https://leetcode.cn/problems/linked-list-cycle-ii/
来源:力扣(LeetCode)
三、解题代码
/**
* 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, *slow = head;
//第一次相遇
while(1){
//如果没有环,fast先结束
if(fast==NULL||fast->next == NULL){
return NULL;
}
fast = fast->next->next;
slow = slow->next;
if(fast==slow){
break;
}
}
//第二次相遇
fast = head;
while(fast != slow){
fast = fast->next;
slow = slow->next;
}
return fast;
}
};