五、19.删除链表的倒数第N个节点
题解参考:代码随想录 (programmercarl.com)
原题链接:19. 删除链表的倒数第 N 个结点 - 力扣(LeetCode)
1. 题目描述
给你一个链表,删除链表的倒数第
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
进阶:你能尝试使用一趟扫描实现吗?
2. 解题思路
这道题是双指针的经典应用。大致思路如下:如果要删除倒数第n
个节点,先让fast
提前移动n
步,然后让fast
和slow
同时移动,直到fast
指向链表末尾。删掉slow
所指向的节点就可以了。
3. 快慢指针法
这道题的大致解法如上所述,但是我们具体实现代码的时候,还需要注意一些细节。
具体实现步骤如下所示:
-
定义
fast
指针和slow
指针,初始值为虚拟头结点,如图: -
fast
先走n + 1
步 。为什么是n+1呢,因为这样的话,当fast
和slow
同时移动的时候slow
才能指向删除节点的上一个节点(方便做删除操作),如图: -
fast
和slow
同时移动,直到fast
指向末尾,如图:
- 删除
slow
指向的下一个节点,如图:
代码如下所示(C语言版)
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
typedef struct ListNode ListNode;
// 定义虚拟头结点
ListNode* dummyHead = (ListNode*)malloc(sizeof(ListNode));
dummyHead->val = 0;
dummyHead->next = head;
// 定义快慢指针
ListNode* fast = dummyHead;
ListNode* slow = dummyHead;
// fast指针先走n+1步,这样的话最终slow指针会指向要删除节点的上一个节点
n++;
while (n-- && fast != NULL) {
fast = fast->next;
}
// fast和slow同时移动
while (fast) {
fast = fast->next;
slow = slow->next;
}
// 此时slow指向要删除节点的前一个节点
slow->next = slow->next->next;
ListNode* ans = dummyHead->next;
free(dummyHead);
return ans;
}
- 时间复杂度:
O(n)
,其中*n
*是链表的长度。 - 空间复杂度:
O(1)
。
代码如下所示(Java版)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
// 定义虚拟头结点
ListNode dummyHead = new ListNode(0, head);
// 定义快慢指针
ListNode fast = dummyHead;
ListNode slow = dummyHead;
// 让快指针先走n+1步
for(int i = 0; i < n + 1; i++) {
fast = fast.next;
}
// 让fast和slow同时移动
while (fast != null) {
fast = fast.next;
slow = slow.next;
}
// 删除slow指向的下一个节点
slow.next = slow.next.next;
return dummyHead.next;
}
}
- 时间复杂度:
O(n)
,其中*n
*是链表的长度。 - 空间复杂度:
O(1)
。
4. 计算链表长度
这个方法应该是大家比较容易想到的。我们首先从头节点开始对链表进行一次遍历,得到链表的长度L
。随后我们再从头节点开始对链表进行一次遍历,当遍历到第L-n+1
个节点时,它就是我们需要删除的节点。
注意:这里为了与题目中的n
保持一致,节点的编号从1
开始,头节点为编号1
的节点。
为了方便删除操作,我们可以从虚拟头结点开始遍历L-n+1
个节点。当遍历到第L-n+1
个节点时,它的下一个节点就是我们需要删除的节点,这样我们只需要修改一次指针,就能完成删除操作。
代码如下所示
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
// 遍历,计算链表长度
int getLen(struct ListNode* head) {
int len = 0;
while (head) {
len++;
head = head->next;
}
return len;
}
struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
typedef struct ListNode ListNode;
// 定义虚拟头结点
ListNode* dummyHead = (ListNode*)malloc(sizeof(ListNode));
dummyHead->val = 0;
dummyHead->next = head;
// 获取链表长度
int len = getLen(head);
// 当前指向节点
ListNode* cur = dummyHead;
// 遍历数组到L-n+1个位置,这个位置是要删除节点的前一个位置
for (int i = 1; i < len - n + 1; i++) {
cur = cur->next;
}
// 删除cur指向的下一个节点
cur->next = cur->next->next;
ListNode* ans = dummyHead->next;
free(dummyHead);
return ans;
}
- 时间复杂度:
O(n)
,其中*n
*是链表的长度。 - 空间复杂度:
O(1)
。
5. 总结
双指针是一种比较高频的算法,对于链表题,我们可以优先考虑能不能用它做。