LeetCode题练习与总结：删除链表的倒数第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

二、解题思路

1. 创建一个虚拟头结点（dummy head），它的 next 指针指向原始链表的头结点。这样做的好处是，无论删除的是头结点还是其他位置的结点，我们都可以统一处理，不需要对头结点进行特殊处理。
2. 初始化两个指针，fast 和 slow，都指向虚拟头结点。
3. 让 fast 指针先走 n 步，这样 fast 和 slow 之间的距离就是 n 个结点。
4. 然后同时移动 fast 和 slow 指针，直到 fast 指针到达链表的末尾。
5. 此时，slow 指针的下一个结点（slow.next）就是要删除的结点。
6. 修改 slow.next 指针，使其指向要删除结点的下一个结点，从而实现删除操作。
7. 返回虚拟头结点的下一个结点，即新的链表头结点。

三、具体代码

class Solution {

    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 创建虚拟头结点
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        // 初始化两个指针
        ListNode fast = dummy;
        ListNode slow = dummy;

        // 让 fast 指针先走 n 步
        for (int i = 0; i < n; i++) {
            fast = fast.next;
        }

        // 同时移动 fast 和 slow 指针
        while (fast != null && fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }

        // 删除操作
        ListNode toBeRemoved = slow.next;
        slow.next = slow.next.next;

        // 返回新的头结点
        return dummy.next;
    }
}

四、时间复杂度和空间复杂度

这段代码的时间复杂度是 O(m)，空间复杂度是 O(1)。

1. 时间复杂度

• 创建虚拟头结点和初始化两个指针的操作是常数时间复杂度 O(1)。
• fast 指针先走 n 步，时间复杂度为 O(n)。
• 然后 fast 和 slow 指针同时移动，直到 fast 到达链表末尾。这个过程的时间复杂度是 O(m)，其中 m 是链表的长度。
• 删除操作（修改 slow.next）是常数时间复杂度 O(1)。

综合以上步骤，整个算法的时间复杂度是 O(n + m)，但由于 n 是 m 的一部分（n <= m），所以可以简化为 O(m)。

2. 空间复杂度

• 创建了一个虚拟头结点，这增加了一个额外的空间。
• fast 和 slow 指针都是局部变量，它们的空间复杂度是 O(1)。

因此，整个算法的空间复杂度是 O(1)，因为我们只使用了常数个额外的空间。

五、总结知识点

1. 虚拟头结点（Dummy Node）：创建一个虚拟头结点来简化链表操作，特别是在处理头结点的删除时，可以避免特殊情况的处理。

2. 双指针技巧：使用两个指针（fast 和 slow）来遍历链表。fast 指针先行 n 步，然后两个指针同时移动，这样可以在 fast 到达链表末尾时，slow 指针正好指向要删除的节点的前一个节点。

3. 链表操作：理解链表的基本结构和操作，如如何通过指针操作来移动节点，以及如何修改节点的 next 指针来实现节点的删除。

4. 循环控制：使用 for 循环和 while 循环来控制 fast 指针的移动，以及同时移动 fast 和 slow 指针。

5. 条件判断：在 while 循环中使用条件判断（fast != null && fast.next != null）来确保 fast 指针不会越界。

6. 链表的返回值：返回新的头结点（dummy.next），这是在删除操作后链表的新起点。

7. 链表节点的创建和引用：创建新的 ListNode 对象（如 dummy 和 toBeRemoved），并正确地引用和操作这些节点。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。