删除链表的倒数第 N 个结点_链表 dumpy-优快云博客

解题思路（快慢指针法）

初始化快慢指针
- 先让 快指针（dumpy） 从链表头开始，向前移动 n 步，使 快慢指针之间的间距为 n。
- 这样，当 快指针到达链表末尾 时，慢指针（p） 就刚好停在 待删除节点的前一个节点。
使用虚拟头节点
- 为了 简化删除头节点的情况，创建一个新的虚拟节点 p，并让 p.next 指向 head。
- 这样，无论删除的是 头节点还是中间节点，都能用 统一逻辑处理，避免特殊判断。
同步移动快慢指针
- 继续移动 快慢指针，直到 快指针的 next 为空，即快指针到达链表末尾。
- 此时，慢指针的 next 指向的就是待删除节点。
删除目标节点
- 让 p.next = p.next.next，跳过该节点，实现删除操作。
- 如果删除的是头节点，则返回 temp.next，否则返回原始 head。

public ListNode removeNthFromEnd(ListNode head, int n) {
    
    // 创建一个虚拟头节点 dumpy（可以防止删除头节点时出现特殊情况）
    ListNode dumpy = new ListNode(-1, head);

    // p 指针用于找到待删除节点的前一个节点
    ListNode p = dumpy;

    // 让 dumpy 指针先向前移动 n 步，确保 dumpy 和 p 之间的距离为 n
    for (int i = 0; i < n; i++) {
        dumpy = dumpy.next;
    }

    // 让 dumpy 和 p 同时向前移动，直到 dumpy 到达链表末尾
    // 此时 p 指向待删除节点的前一个节点
    while (dumpy != null && dumpy.next != null) {
        p = p.next;
        dumpy = dumpy.next;
    }

    // 删除该节点，即跳过 temp
    p.next = p.next.next;

    // 若删除的是头节点，则返回 temp.next，否则返回原链表头节点
    return temp == head ? temp.next : head;
}

这个返回是使用边界条件想到的，例如输入：head = [1], n = 1
输入：head = [1，2], n = 2

  // 若删除的是头节点，则返回 temp.next，否则返回原链表头节点
    return temp == head ? temp.next : head;

时间复杂度

时间复杂度：O(L)，其中 L 是链表的长度。快指针需要走 n+1 步，然后快慢指针一起走到链表的末尾，总共需要遍历一次链表。

空间复杂度

空间复杂度：O(1)。

方法2

代码解析：删除链表的倒数第 N 个节点（快慢指针法）

public ListNode removeNthFromEnd(ListNode head, int n) {

    // 创建一个虚拟头节点，方便处理删除头节点的特殊情况
    ListNode dummy = new ListNode(0, head);
    // first 和 second 都指向虚拟头节点，准备执行快慢指针法
    ListNode first = dummy;
    ListNode second = dummy;

    // 让 first 指针向前走 n+1 步
    // 这样 first 和 second 之间的距离为 n，确保 second 指向的是倒数第 n+1 个节点
    for (int i = 0; i <= n; i++) {
        first = first.next;
    }

    // 同时移动 first 和 second，直到 first 指针到达链表的末尾
    // 此时 second 指向的是倒数第 n+1 个节点，second.next 就是倒数第 n 个节点
    while (first != null) {
        first = first.next;
        second = second.next;
    }

    // 删除 second.next 指向的节点，即倒数第 n 个节点
    second.next = second.next.next;

    // 返回链表的头节点，注意头节点可能被删除，因此返回 dummy.next
    return dummy.next;
}

解题思路

虚拟头节点：通过创建一个虚拟头节点 (dummy) 来处理头节点被删除的特殊情况，这样就能统一处理链表中任意节点的删除。
快慢指针：
- 快指针 (first) 从虚拟头节点开始，先走 n+1 步，确保它和 慢指针 (second) 之间有 n 个节点的距离。
- 然后 快指针 和 慢指针 同时移动，直到 快指针 到达链表的末尾。此时，慢指针 的下一个节点 (second.next) 就是倒数第 n 个节点。
删除节点：通过改变 慢指针 (second) 的 next 指针，跳过倒数第 n 个节点，从而实现删除操作。

时间复杂度

时间复杂度：O(L)，其中 L 是链表的长度。快指针需要走 n+1 步，然后快慢指针一起走到链表的末尾，总共需要遍历一次链表。

空间复杂度

空间复杂度：O(1)。只使用了常数级别的额外空间，除了几个指针（dummy, first, second），没有使用额外的存储空间。

public ListNode removeNthFromEnd(ListNode head, int n) {

    // 创建一个虚拟头节点，方便处理删除头节点的特殊情况
    ListNode dummy = new ListNode(-1, head);
    // first 和 second 都指向虚拟头节点，准备执行快慢指针法
    ListNode first = dummy;
    ListNode second = dummy;

    // 让 first 指针向前走 n+1 步
    // 这样 first 和 second 之间的距离为 n，确保 second 指向的是倒数第 n+1 个节点
    for (int i = 0; i <= n; i++) {
        first = first.next;
    }

    // 同时移动 first 和 second，直到 first 指针到达链表的末尾
    // 此时 second 指向的是倒数第 n+1 个节点，second.next 就是倒数第 n 个节点
    while (first != null) {
        first = first.next;
        second = second.next;
    }

    // 删除 second.next 指向的节点，即倒数第 n 个节点
    second.next = second.next.next;

    // 返回链表的头节点，注意头节点可能被删除，因此返回 dummy.next
    return dummy.next;
}