【力扣Hot 100】链表4

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 <= 30
0 <= Node.val <= 100
1 <= 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 <= 5000
0 <= 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;
    }
};