文章目录

• 题目
• • 标题和出处
  • 难度
  • 题目描述
  • • 要求
    • 示例
    • 数据范围
    • 进阶
• 解法一
• • 思路和算法
  • 代码
  • 复杂度分析
• 解法二
• • 思路和算法
  • 代码
  • 复杂度分析

题目

标题和出处

标题：删除链表的倒数第 N 个结点

出处：19. 删除链表的倒数第 N 个结点

难度

3 级

题目描述

要求

给你一个链表，删除链表的倒数第 $\text{n}$ 个结点，然后返回链表的头结点。

示例

示例 1：

输入：$\text{head = [1,2,3,4,5], n = 2}$
输出：$\text{[1,2,3,5]}$

示例 2：

输入：$\text{head = [1], n = 1}$
输出：$\text{[]}$

示例 3：

输入：$\text{head = [1,2], n = 1}$
输出：$\text{[1]}$

数据范围

• 链表中结点的数目为 $\text{sz}$
• $\text{1}\le \text{sz}\le \text{30}$
• $\text{0}\le \text{Node.val}\le \text{100}$
• $\text{1}\le \text{n}\le \text{sz}$

进阶

你能使用一次遍历实现吗？

解法一

思路和算法

最直观的做法是，首先遍历链表得到链表的结点数量 $\text{sz}$，然后再次遍历链表，找到待删除的结点并将其删除。当链表的结点数量是 $\text{sz}$ 时，删除倒数第 $n$ 个结点等价于删除正数第 $\text{sz}-n+1$ 个结点。

当 $n=\text{sz}$ 时，待删除的结点为链表的头结点，因此返回 $\text{head}.\text{next}$。

当 $n<\text{sz}$ 时，定位到待删除结点的前一个结点 $\text{temp}$，然后将结点 $\text{temp}.\text{next}$ 删除。具体做法如下：

1. 结点 $\text{temp}$ 为链表的正数第 $\text{sz}-n$ 个结点，因此从 $\text{head}$ 开始向后移动 $\text{sz}-n-1$ 次，即可得到结点 $\text{temp}$；

2. 删除 $\text{temp}$ 的后一个结点，可通过改变 $\text{next}$ 指针的指向实现，令 $\text{temp}.\text{next}$ 指向 $\text{temp}.\text{next}.\text{next}$ 即可。

如果待删除的结点是链表的最后一个结点，上述做法同样适用，在删除结点之后，$\text{temp}.\text{next}$ 将指向 $\text{null}$。

下图为示例 1 的删除结点的过程。此时 $\text{sz}=5$，$n=2$，待删除的结点是正数第 $4$ 个结点，因此定位到正数第 $3$ 个结点，然后令正数第 $3$ 个结点的 $\text{next}$ 指向正数第 $5$ 个结点，完成删除操作。

代码

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int sz = 0;
        ListNode temp = head;
        while (temp != null) {
            sz++;
            temp = temp.next;
        }
        if (n == sz) {
            return head.next;
        }
        temp = head;
        int before = sz - n;
        for (int i = 1; i < before; i++) {
            temp = temp.next;
        }
        temp.next = temp.next.next;
        return head;
    }
}

复杂度分析

• 时间复杂度：$O(\text{sz})$，其中 $\text{sz}$ 是链表的长度。最多需要遍历链表两次，删除结点的时间为 $O(1)$。

• 空间复杂度：$O(1)$。

解法二

思路和算法

上述解法需要首先得到链表的结点数量 $\text{sz}$，然后进行删除操作，因此需要两次遍历。其实，链表的结点数量 $\text{sz}$ 不需要事先知道，一次遍历也可以完成删除操作。

由于待删除的是倒数第 $n$ 个结点，因此可以想到使用两个指针，这两个指针指向的结点在链表中相差 $n$ 个位置。用 ${\text{temp}}_1$ 和 ${\text{temp}}_2$ 分别表示两个指针，其中 ${\text{temp}}_2$ 在 ${\text{temp}}_1$ 的后面 $n$ 个位置。当 ${\text{temp}}_2$ 指向链表的最后一个结点时，${\text{temp}}_1$ 指向待删除结点的前一个结点。

由于待删除的结点可能是链表的头结点，因此需要创建哑节点 $\text{dummyHead}$，使得 $\text{dummyHead}.\text{next}=\text{head}$。将两个指针 ${\text{temp}}_1$ 和 ${\text{temp}}_2$ 初始化为都指向 $\text{dummyHead}$，然后将 ${\text{temp}}_2$ 向后移动 $n$ 次，即满足 ${\text{temp}}_2$ 在 ${\text{temp}}_1$ 的后面 $n$ 个位置。

当 ${\text{temp}}_1$ 和 ${\text{temp}}_2$ 满足相差 $n$ 个位置时，同时将两个指针向后移动，直到 ${\text{temp}}_2$ 指向链表的最后一个结点，此时 ${\text{temp}}_1$ 指向待删除结点的前一个结点。将 ${\text{temp}}_1$ 定位到待删除结点的前一个结点之后，令 ${\text{temp}}_1.\text{next}$ 指向 ${\text{temp}}_1.\text{next}.\text{next}$，即可完成删除操作。

完成删除操作之后，新的头结点为哑节点的下一个结点，因此返回 $\text{dummyHead}.\text{next}$。

下图为示例 1 的删除结点的过程，图中的灰色结点表示哑节点。此时 $n=2$，因此将 ${\text{temp}}_2$ 移动到和 ${\text{temp}}_1$ 相差 $2$ 个位置，然后同时向后移动 ${\text{temp}}_1$ 和 ${\text{temp}}_2$，直到 ${\text{temp}}_2$ 指向链表的最后一个结点，${\text{temp}}_1$ 指向待删除结点的前一个结点，删除 ${\text{temp}}_1$ 指向的结点的下一个结点。最后返回哑节点的下一个结点。

代码

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyHead = new ListNode(0, head);
        ListNode temp1 = dummyHead, temp2 = dummyHead;
        for (int i = 0; i < n; i++) {
            temp2 = temp2.next;
        }
        while (temp2.next != null) {
            temp1 = temp1.next;
            temp2 = temp2.next;
        }
        temp1.next = temp1.next.next;
        return dummyHead.next;
    }
}

复杂度分析

• 时间复杂度：$O(\text{sz})$，其中 $\text{sz}$ 是链表的长度。需要遍历链表一次，删除结点的时间为 $O(1)$。

• 空间复杂度：$O(1)$。