删除链表的倒数第 N 个结点：一场C++中的时间旅行-CSDN博客

本文链接：https://blog.csdn.net/master_chenchen/article/details/140250725

删除链表的倒数第 N 个结点：一场C++中的时间旅行

引言

在算法的世界里，链表如同一条条蜿蜒曲折的小径，引领我们穿越数据结构的森林。而删除链表的倒数第N个结点，就像是在时间的长河中寻找那颗遗落的珍珠，既考验着我们的逻辑思维，也挑战着我们的编程技巧。本文旨在通过生动有趣的例子，带领你探索这一问题的解法，同时，我们将一起学习如何在C++中优雅地实现这一功能，让算法之美跃然纸上。

文章目的

本文的目标是让读者不仅能够理解删除链表倒数第N个结点的原理，还能掌握其实现细节，并学会如何在实际项目中巧妙运用。无论你是刚踏入编程领域的新人，还是在C++世界中游刃有余的老手，都将从这篇指南中获得新的启示。

技术概述

定义与简介

链表是一种常见的线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。删除链表的倒数第N个结点，意味着我们需要找到从链表尾部开始的第N个节点，并将其从链表中移除。

核心特性和优势

双指针技巧：使用两个指针，一个先走N步，然后另一个开始移动，直到第一个指针到达链表末尾，此时第二个指针正好位于目标节点的前一个位置。
一次遍历：通过巧妙的设计，可以只遍历一次链表就能完成任务，提高了算法的效率。

代码示例

让我们通过一个C++代码片段，来直观地感受如何实现删除链表的倒数第N个结点的功能：

#include <iostream>

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode *first = &dummy, *second = &dummy;
    
    // Move first pointer so that the gap between first and second is n nodes apart
    for (int i = 0; i <= n; ++i) {
        first = first->next;
    }
    
    // Move first to the end, maintaining the gap
    while (first != nullptr) {
        first = first->next;
        second = second->next;
    }
    
    second->next = second->next->next;
    return dummy.next;
}

void printList(ListNode* head) {
    while (head != nullptr) {
        std::cout << head->val << " -> ";
        head = head->next;
    }
    std::cout << "nullptr" << std::endl;
}

int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(5);

    std::cout << "Original List: ";
    printList(head);
    
    head = removeNthFromEnd(head, 2);
    
    std::cout << "After Removing 2nd from End: ";
    printList(head);
    
    return 0;
}

技术细节

在删除链表的倒数第N个结点时，最大的挑战是如何准确地定位到该结点。双指针技巧为我们提供了一种优雅的解决方案，它不仅简化了问题，还保证了算法的效率。

分析与难点

难点在于如何保证两个指针之间的距离始终保持为N。这要求我们对链表的遍历和指针的移动有精确的控制。

实战应用

删除链表的倒数第N个结点这一问题，不仅在面试中经常出现，也是实际软件开发中可能遇到的场景。例如，在处理日志文件或实现缓存机制时，可能需要定期删除最近最少使用的记录，这时，链表的倒数删除功能就派上了用场。

案例分析

假设你正在开发一个简单的缓存系统，需要维护一个固定大小的缓存列表。每当缓存满时，你就需要删除最旧的记录，以腾出空间给新数据。这时，删除链表的倒数第N个结点（这里N是缓存大小减一）的技巧，就可以帮助你高效地实现这一需求。

优化与改进

尽管双指针技巧已经非常高效，但在处理大型链表时，我们仍然需要关注算法的性能。例如，如果链表非常长，那么即使一次遍历也可能消耗大量时间。

优化建议

预处理：如果链表中节点的访问频率不均，可以考虑预先计算链表的长度，这样在需要删除倒数第N个结点时，可以直接定位，而无需再次遍历整个链表。
双向链表：在某些情况下，使用双向链表代替单向链表，可以使删除操作更加直接，尤其是当需要频繁执行删除操作时。

代码示例

使用双向链表进行优化：

struct ListNode {
    int val;
    ListNode *prev, *next;
    ListNode(int x) : val(x), prev(nullptr), next(nullptr) {}
};

// ... 其他代码保持不变，只需在removeNthFromEnd函数中稍作修改

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode dummy(0);
    dummy.next = head;
    head->prev = &dummy;
    
    ListNode *first = &dummy, *second = &dummy;
    
    for (int i = 0; i <= n; ++i) {
        first = first->next;
    }
    
    while (first != nullptr) {
        first = first->next;
        second = second->next;
    }
    
    second->prev->next = second->next;
    if (second->next != nullptr) {
        second->next->prev = second->prev;
    }
    
    return dummy.next;
}

常见问题

在实现删除链表的倒数第N个结点时，开发者可能会遇到一些常见的陷阱，如处理空链表或链表只有一个节点的情况，以及如何避免指针越界等问题。

解决方案

为了避免这些陷阱，可以在算法开始之前，先进行一些预检查，确保链表的结构完整，再进行后续操作。此外，使用哑结点（dummy node）可以简化边界条件的处理，使得代码更加健壮。

代码示例

通过使用哑结点简化边界处理：

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode dummy(0);
    dummy.next = head;
    
    ListNode *first = &dummy, *second = &dummy;
    
    // ... 其他代码保持不变
}