链表篇：五、19.删除链表的倒数第N个节点

五、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. 快慢指针法

这道题的大致解法如上所述，但是我们具体实现代码的时候，还需要注意一些细节。

具体实现步骤如下所示：

1. 定义fast指针和slow指针，初始值为虚拟头结点，如图：

   

2. fast先走n + 1步 。为什么是n+1呢，因为这样的话，当fast和slow同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图：

   

3. fast和slow同时移动，直到fast指向末尾，如图：

4. 删除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. 总结

双指针是一种比较高频的算法，对于链表题，我们可以优先考虑能不能用它做。