LeetCode 算法：删除链表的倒数第 N 个结点 c++

原题链接🔗：删除链表的倒数第 N 个结点
难度：中等⭐️⭐️

题目

给你一个链表，删除链表的倒数第 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

进阶：你能尝试使用一趟扫描实现吗？

题解

双指针法

1. 题解：

LeetCode 上的 “删除链表的倒数第 N 个结点” 问题是链表操作中的一个经典问题。这个问题可以通过双指针技术来解决。以下是解题思路：

• 理解问题：题目要求删除链表中倒数第 N 个节点。例如，如果链表是 1->2->3->4->5，N=2，那么删除后应该是
  1->2->3->5。

• 使用虚拟头节点：创建一个虚拟头节点，指向原链表的头节点。这样无论原链表的头节点是否被删除，都能保证算法的通用性。

• 快慢指针：初始化两个指针 fast 和 slow，都指向虚拟头节点。然后移动 fast 指针，使其向前移动 N 步。

• 同时移动两个指针：接着同时移动 fast 和 slow 指针，直到 fast 指针到达链表的末尾。此时，slow 指针将指向倒数第 N
  个节点的前一个节点。

• 删除节点：删除 slow 指针的下一个节点，即将 slow->next 指向 slow->next->next。

• 特殊情况处理：如果 N 大于链表长度，或者链表为空，则无需删除任何节点。

• 返回结果：返回虚拟头节点的下一个节点，即原链表的新头节点。

2. 复杂度：时间复杂度O(L)，其中L是链表的长度，空间复杂度O(1)。
3. 代码过程：如demo所示。

• 首先定义了 ListNode 结构体;
• 然后实现了 removeNthFromEnd 函数，该函数接收链表的头节点和要删除的节点的索引n。函数内部使用了一个虚拟头节点来简化代码逻辑，并使用双指针技术来找到并删除倒数第 n 个节点。
• 最后，main 函数中创建了一个示例链表，调用了 removeNthFromEnd函数，并打印了修改后的链表。
• 最后，不要忘记释放链表占用的内存以避免内存泄漏。

4. c++ demo：

#include <iostream>

// 定义链表节点结构体
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

// 删除链表的倒数第N个节点
ListNode* removeNthFromEnd(ListNode* head, int n) {
    // 创建虚拟头节点，简化边缘情况处理
    ListNode* dummy = new ListNode(0);
    dummy->next = head;

    // 初始化两个指针，p1 和 p2，都指向虚拟头节点
    ListNode* p1 = dummy, * p2 = dummy;

    // 使 p1 先走 n 步
    for (int i = 0; i < n; ++i) {
        p1 = p1->next;
    }

    // 当 p1 到达第 n 个节点时，p2 开始移动
    // 当 p1 到达链表末尾时，p2 到达倒数第 n 个节点的前一个节点
    while (p1 != nullptr) {
        p1 = p1->next;
        p2 = p2->next;
    }

    // 删除倒数第 n 个节点
    ListNode* toDelete = p2->next;
    p2->next = p2->next->next;

    // 释放被删除节点的内存
    delete toDelete;

    // 返回调整后的链表头节点，注意跳过虚拟头节点
    ListNode* newHead = dummy->next;
    delete dummy; // 释放虚拟头节点
    return newHead;
}

// 打印链表的辅助函数
void printList(ListNode* node) {
    while (node != nullptr) {
        std::cout << node->val << " -> ";
        node = node->next;
    }
    std::cout << "null" << std::endl;
}

// 测试用例
int main() {
    // 创建一个示例链表: 1 -> 2 -> 3 -> 4 -> 5
    ListNode* list = new ListNode(1);
    list->next = new ListNode(2);
    list->next->next = new ListNode(3);
    list->next->next->next = new ListNode(4);
    list->next->next->next->next = new ListNode(5);

    std::cout << "Original List: ";
    printList(list);

    // 删除倒数第 2 个节点
    ListNode* newList = removeNthFromEnd(list, 2);

    std::cout << "Modified List: ";
    printList(newList);

    // 释放链表内存
    while (newList != nullptr) {
        ListNode* temp = newList;
        newList = newList->next;
        delete temp;
    }

    return 0;
}

• 输出结果：

Original List: 1 -> 2 -> 3 -> 4 -> 5 -> null
Modified List: 1 -> 2 -> 3 -> 4 -> null

其他方法

• 计算链表长度法。
• 栈法。