24.两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
输入：head = [1,2,3,4] 输出：[2,1,4,3] 示例 2： 输入：head = [] 输出：[] 示例 3： 输入：head = [1] 输出：[1]
提示：
- 链表中节点的数目在范围 [0, 100] 内
- 0 <= Node.val <= 100
思路
关键是要把cur指针前后的节点保存到临时节点中 我在这里使用了pre和last两个临时节点
题解
/**
* 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,head);
ListNode *cur = dummyhead;
while(cur->next!=nullptr&&cur->next->next!=nullptr){
ListNode *pre=cur->next;
ListNode *last=cur->next->next->next;
cur->next=cur->next->next;
cur->next->next=pre;
cur->next->next->next=last;
cur=cur->next->next;
}
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]
提示：
- 链表中结点的数目为 sz
- 1 <= sz <= 30
- 0 <= Node.val <= 100
- 1 <= n <= sz
进阶：你能尝试使用一趟扫描实现吗？
思路
这道题的边界条件有点难处理，分析的方法仍然是模拟过程 快指针先走n+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,head);
ListNode *fast, *slow;
fast=slow=dummyhead;
while(n--&&fast!=nullptr){//实际上走了n步
fast=fast->next;
}
fast=fast->next;//这个很关键，实现n+1步
while(fast!=nullptr){
slow=slow->next;
fast=fast->next;
}
ListNode *tmp=slow->next;
slow->next=slow->next->next;
delete tmp;
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]
思路
这道题确实很吃阅读理解，找出数学规律后实现并不难
首先，我们需要明确一点：如果两个链表在某点相交，那么从这个交点开始，它们共享所有的节点，直到链表的末尾。这意味着，从交点开始，两个链表的剩余长度是相同的。
现在，考虑两个链表A和B，它们的长度分别为lenA和lenB。假设它们在某点相交，从头节点到交点的长度分别为a和b，从交点到链表末尾的长度为c。
因此，我们有：
lenA = a + c
lenB = b + c
当指针pA从链表A的头部开始遍历并到达末尾时，它已经走了lenA的长度。然后，它从链表B的头部开始遍历。当pA到达交点时，它走了lenA + b的长度。
同样，当指针pB从链表B的头部开始遍历并到达末尾时，它已经走了lenB的长度。然后，它从链表A的头部开始遍历。当pB到达交点时，它走了lenB + a的长度。
现在，观察这两个长度：
lenA + b = a + c + b
lenB + a = b + c + a
你会发现，这两个长度是相同的！这意味着，当pA和pB都走了这个长度时，它们都会到达交点。
因此，如果两个链表相交，那么pA和pB必定会在交点处相遇。
题解
/**
* 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) {
if (!headA || !headB) {
return NULL;
}
ListNode *pA = headA, *pB = headB;
while (pA != pB) {
pA = pA ? pA->next : headB;
pB = pB ? pB->next : headA;
}
return pA;
}
};
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) 空间解决此题？
思路
- 检测环：使用两个指针，一个快指针（每次移动两步）和一个慢指针（每次移动一步）。如果链表中存在环，那么快指针和慢指针最终会在环内的某个位置相遇。
- 确定环的起点：当快指针和慢指针相遇时，将快指针重新定位到链表的头部，并使其每次移动一步。现在，快指针和慢指针都每次移动一步。当它们再次相遇时，相遇点就是环的起点。
为什么这样做？
假设从链表头部到环的起点的距离为a，环的起点到快慢指针相遇点的距离为b，相遇点到环的起点的距离为c。
当快慢指针相遇时，慢指针走了a + b，快指针走了a + b + c + b（因为快指针走了整个环的长度加上从环的起点到相遇点的距离）。由于快指针的速度是慢指针的两倍，所以2(a + b) = a + 2b + c。从这个等式中，我们可以得出a = c。这意味着从链表头部到环的起点的距离等于从相遇点到环的起点的距离。
题解
/**
* 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 || !head->next) {
return NULL;
}
ListNode *slow = head, *fast = head;
// Step 1: Check for cycle
while (fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) {
break;
}
}
// If no cycle found
if (slow != fast) {
return NULL;
}
// Step 2: Find the start of the cycle
fast = head;
while (slow != fast) {
slow = slow->next;
fast = fast->next;
}
return slow;
}
};
这种方法确保了时间复杂度为O(n)和空间复杂度为O(1)。
