8. 删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第 n **个结点，并且返回链表的头结点。
示例 1：
!https://assets.leetcode.com/uploads/2020/10/03/remove_ex1.jpg
输入：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 <= 300 <= Node.val <= 1001 <= n <= sz
**进阶：**你能尝试使用一趟扫描实现吗？
题解
一个快指针，一个慢指针，快指针比慢指针提前 N 步，两个都每次走一格，当快指针指向 nullptr 的时候，慢指针刚好指向要删除的结点。
为了更好的删除要删除的结点，慢指针从 head 前面一个指针开始。
cpp
/**
* 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 *pre = new ListNode(-1, head);
ListNode *slow = pre, *fast = head;
for(int i = 0; i < n; i ++ ) {
fast = fast->next;
}
while(fast) {
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
return pre->next;
}
};9. 两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
!https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
- 链表中节点的数目在范围
[0, 100]内 0 <= Node.val <= 100
题解
用了一个哑节点。我只用迭代。
cpp
/**
* 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 *preHead = new ListNode(-1, head);
ListNode *prev = preHead;
while(prev->next && prev->next->next) {
ListNode *curr1 = prev->next, *curr2 = prev->next->next;
curr1->next = curr2->next;
curr2->next = curr1;
prev->next = curr2;
prev = curr1;
}
return preHead->next;
}
};10. K个一组翻转链表
给你链表的头节点 head ，每 k **个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k **的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
示例 1：
!https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：
!https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
提示：
- 链表中的节点数目为
n 1 <= k <= n <= 50000 <= Node.val <= 1000
题解
根本不想再做第二遍。。
首先定义一个翻转链表的函数：给定head，tail，返回翻转后的 head 和 tail 。
定义一个指针 prev 和指针 tail，初始时都指向preHead。prev 指向要翻转的链表表头的前面一位，tail 指向要翻转的链表的最后一位。
while 循环结束的条件是 tail 为空。每次循环，我们都让 tail 往后走 k 步，如果不够就返回结果。这样，tail 就能指向要翻转的链表的最后一位。
然后，我们先存储 tail→next，这样要翻转的链表的前面一个节点和后面一个节点都存下来了。再把 prev→next 和 tail 丢进翻转链表函数中，得到新的链表的 newHead 和 newTail。我们更新 prev 和 tail都为 newTail，这样就能进行下一轮循环了。
cpp
/**
* 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:
pair<ListNode*, ListNode*> reverseList(ListNode *head, ListNode *tail) {
ListNode *preHead = new ListNode(-1, head);
ListNode *prev = preHead, *curr = head;
while(curr != tail) {
ListNode *ne = curr->next;
curr->next = prev;
prev = curr;
curr = ne;
}
curr->next = prev;
return {tail, head};
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode *preHead = new ListNode(-1, head);
ListNode *prev = preHead, *tail = preHead;
while(tail) {
// tail向后走k步，如果没有k步就返回
for(int i = 0; i < k; i ++ ) {
tail = tail->next;
if(!tail) return preHead->next;
}
// 存储后面的节点
ListNode *ne = tail->next;
// 调用函数，翻转链表
auto result = reverseList(prev->next, tail);
// 接入翻转后的新链表
ListNode *newHead = result.first, *newTail = result.second;
prev->next = newHead;
newTail->next = ne;
// 更新 prev, tail
prev = newTail;
tail = newTail;
}
return preHead->next;
}
};