目录

一、反转链表

二、反转链表 ||

三、两两交换链表中的结点

四、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)// 更新 tmptmp = 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){// 判断剩余长度是否大于或等于 kstruct 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)// 更新 tmptmp = last;}head = guard->next;free(guard);return head;
}

图解示例二：