目录
一、反转链表
二、反转链表 ||
三、两两交换链表中的结点
四、K 个一组翻转链表
一、反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：
-
链表中节点的数目范围是
[0, 5000] -
-5000 <= Node.val <= 5000
代码实现一：
struct ListNode* reverseList(struct ListNode* head)
{
struct ListNode* pre = NULL;
struct ListNode* cur = head;
while (cur != NULL)
{
struct ListNode* after = cur->next;
cur->next = pre;
pre = cur;
cur = after;
}
return pre;
}
代码实现二（将结点依次头插到新链表中）：
struct ListNode* reverseList(struct ListNode* head)
{
struct ListNode* newhead = NULL;
struct ListNode* cur = head;
while (cur != NULL)
{
struct ListNode* after = cur->next;
// 头插
cur->next = newhead;
newhead = cur;
cur = after;
}
return newhead;
}二、反转链表 ||
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。
示例 1：
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]
示例 2：
输入：head = [5], left = 1, right = 1
输出：[5]
提示：
-
链表中节点数目为
n -
1 <= n <= 500 -
-500 <= Node.val <= 500 -
1 <= left <= right <= n
进阶： 你可以使用一趟扫描完成反转吗？
代码实现：
struct ListNode* reverseBetween(struct ListNode* head, int left, int right)
{
struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
guard->next = head;
struct ListNode* tmp = guard;
// 1. 让 tmp 指向第 left - 1 个结点（不包括哨兵位的头结点）
for (int i = 0; i < left - 1; ++i)
{
tmp = tmp->next;
}
// 2. 反转从位置 left 到位置 right 的链表结点
struct ListNode* pre = tmp->next;
struct ListNode* cur = pre->next;
for (int i = 0; i < right - left; ++i)
{
struct ListNode* after = cur->next;
cur->next = pre;
pre = cur;
cur = after;
}
// 经过反转，tmp->next 指向的结点变成了从位置 left 到位置 right 中最后一个结点，
// 而 pre 指向的结点则变成了第一个结点
tmp->next->next = cur; // (1)
tmp->next = pre; // (2)
head = guard->next;
free(guard);
return head;
}图解示例一：
三、两两交换链表中的结点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
-
链表中节点的数目在范围
[0, 100]内 -
0 <= Node.val <= 100
代码实现：
struct ListNode* swapPairs(struct ListNode* head)
{
// 创建一个哨兵位的头结点
struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
guard->next = head;
// 交换 tmp 后面的两个结点
struct ListNode* tmp = guard;
while (tmp->next && tmp->next->next)
{
struct ListNode* node1 = tmp->next;
struct ListNode* node2 = tmp->next->next;
tmp->next = node2; // (1)
node1->next = node2->next; // (2)
node2->next = node1; // (3)
// 更新 tmp
tmp = node1;
}
head = guard->next;
free(guard);
return head;
}
四、K 个一组翻转链表
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
提示：
-
链表中的节点数目为
n -
1 <= k <= n <= 5000 -
0 <= Node.val <= 1000
代码实现：
struct ListNode* reverseKGroup(struct ListNode* head, int k)
{
struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
guard->next = head;
struct ListNode* tmp = guard;
while (1)
{
// 判断剩余长度是否大于或等于 k
struct ListNode* p = tmp;
for (int i = 0; p != NULL && i < k; ++i)
{
p = p->next;
}
if (p == NULL)
{
break;
}
// 翻转 tmp 后面的 k 个结点
struct ListNode* pre = tmp->next;
struct ListNode* cur = pre->next;
for (int i = 0; i < k - 1; ++i)
{
struct ListNode* after = cur->next;
cur->next = pre;
pre = cur;
cur = after;
}
// 经过翻转后，tmp->next 指向的结点变成了最后一个结点，
// 而 pre 指向的结点则变成成了第一个结点
tmp->next->next = cur; // (1)
struct ListNode* last = tmp->next; // 保存最后一个结点的地址
tmp->next = pre; // (2)
// 更新 tmp
tmp = last;
}
head = guard->next;
free(guard);
return head;
}图解示例二：
