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.解题思路

1. 计算链表长度

   一种容易想到的方法是，我们首先从头节点开始对链表进行一次遍历，得到链表的长度 L。随后我们再从头节点开始对链表进行一次遍历，当遍历到第 L−n+1节点时，它就是我们需要删除的节点。

   

2. 双指针

   • 虚拟头结点

   • 定义fast指针和slow指针，初始值为虚拟头结点

     

   • 快指针（fast）首先向前移动 n 步，这样它和慢指针（slow）之间的距离就是 n 个节点。这是为了找到倒数第 n 个节点。当fast走到最后时，slow与fast之间相差n。刚好为倒数第n个节点

   • 然后，快指针再提前移动一步，这是因为我们需要删除倒数第 n 个节点，而慢指针必须指向要删除节点的前一个节点，以便进行删除操作。所以，fast多走一步。为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）

     

   • fast和slow同时移动，直到fast指向末尾

     

   • 删除slow指向的下一个节点，如图：

     

3.代码

C++：计算链表长度

class Solution {
public:
    int getLength(ListNode* head) {
        int length = 0;
        while (head) {
            length++;
            head = head->next;
        }
        return length;
    }

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        int length = getLength(head);
        ListNode* cur = dummy;
        for (int i = 1; i < length - n + 1; i++) {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        ListNode* ans = dummy->next;
        delete dummy;
        return ans;
    }
};

C++：双指针

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        return dummyHead->next;
    }
};

python：计算链表长度

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        def getLength(head:ListNode)-> int:
            length = 0
            while(head):
                length += 1
                head = head.next
            return length
        
        dummy = ListNode(0)
        dummy.next = head
        cur = dummy
        for i in range(1, length - n + 1):
            cur = cur.next
        cur.next = cur.next.next
        return dummy.next

python：双指针

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        # 创建一个虚拟节点，并将其下一个指针设置为链表的头部
        dummy_head = ListNode(0, head)
        
        # 创建两个指针，慢指针和快指针，并将它们初始化为虚拟节点
        slow = fast = dummy_head
        
        # 快指针比慢指针快 n+1 步
        for i in range(n+1):
            fast = fast.next
        
        # 移动两个指针，直到快速指针到达链表的末尾
        while fast:
            slow = slow.next
            fast = fast.next
        
        # 通过更新第 (n-1) 个节点的 next 指针删除第 n 个节点
        slow.next = slow.next.next
        
        return dummy_head.next