链表操作：删除倒数第N节点的3种解法与优化-代码聚汇网

链表操作：删除倒数第N节点的3种解法与优化

超蜡笔·2026-08-14·阅读 23 GEO检测（免费）

链表操作删除倒数第N节点快慢指针

|难度：普通|阅读约 17 分钟

1. 链表操作的艺术：删除倒数第N节点实战指南

链表操作是数据结构中的经典问题，而删除倒数第N个节点更是面试中的高频考点。这个问题看似简单，却能考察程序员对指针操作、边界条件处理以及算法优化的理解深度。今天我将用C++语言，通过三种截然不同的解法，带你彻底掌握这个问题的精髓。

在实际工程中，链表操作常见于内存管理、文件系统索引等场景。比如Linux内核的任务调度就使用了双向链表，而浏览器缓存淘汰算法LRU的实现也依赖链表操作。理解这些基础操作，对提升代码质量和面试表现都至关重要。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 问题定义与基础解法

2.1 问题明确化

给定一个单向链表，要求删除链表中倒数第N个节点，并返回头节点。例如：

code复制链表：1->2->3->4->5
N=2
结果：1->2->3->5

关键约束：

链表长度可能很大（需考虑时间复杂度）
N保证有效（不需处理N>链表长度的情况）
要求只遍历链表一次（空间复杂度O(1)）

2.2 暴力解法：两次遍历法

最直观的解法是进行两次遍历：

第一次遍历计算链表长度L
第二次遍历找到第(L-N)个节点进行删除

cpp复制ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode dummy(0);
    dummy.next = head;
    int length = 0;
    ListNode* curr = head;
    while (curr) {
        length++;
        curr = curr->next;
    }
    
    int target = length - n;
    curr = &dummy;
    for (int i = 0; i < target; i++) {
        curr = curr->next;
    }
    curr->next = curr->next->next;
    return dummy.next;
}

注意：使用dummy节点可以统一处理头节点删除的情况，这是链表操作的重要技巧

时间复杂度：O(2L) ≈ O(L)
空间复杂度：O(1)

虽然这个解法简单直接，但显然不满足"只遍历一次"的要求。接下来我们看更高效的解法。

3. 进阶解法：快慢指针技巧

3.1 快慢指针原理

快慢指针是链表问题的经典技巧，核心思想是：

快指针先走N步
然后快慢指针同步前进
当快指针到达末尾时，慢指针正好指向倒数第N个节点的前驱

cpp复制ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode *fast = &dummy, *slow = &dummy;
    
    // 快指针先走n步
    for (int i = 0; i < n; i++) {
        fast = fast->next;
    }
    
    // 同步移动直到快指针到末尾
    while (fast->next) {
        fast = fast->next;
        slow = slow->next;
    }
    
    slow->next = slow->next->next;
    return dummy.next;
}

3.2 边界条件处理

实际编码中需要特别注意：

链表为空的情况（题目保证N有效）
删除头节点的情况（使用dummy节点解决）
快指针移动时的空指针检查

cpp复制// 安全检查版本
if (!head || n <= 0) return head;

ListNode dummy(0);
dummy.next = head;
ListNode *fast = &dummy, *slow = &dummy;

// 快指针移动时的安全检查
for (int i = 0; i < n && fast; i++) {
    fast = fast->next;
}
if (!fast) return head; // n大于链表长度

时间复杂度：O(L)
空间复杂度：O(1)

4. 递归解法：利用调用栈反向计数

4.1 递归思路解析

递归解法利用函数调用栈的特性：

递归到链表末尾开始返回
返回时计数器递增
当计数器等于N时，跳过当前节点

cpp复制int count = 0;

ListNode* removeNthFromEnd(ListNode* head, int n) {
    if (!head) return nullptr;
    head->next = removeNthFromEnd(head->next, n);
    count++;
    return count == n ? head->next : head;
}

4.2 递归的优缺点分析

优点：

代码简洁优雅
不需要额外指针操作

缺点：

空间复杂度O(L)（递归栈深度）
链表过长可能导致栈溢出
使用全局变量count不够优雅（可改用类成员或包装函数）

改进版本（避免全局变量）：

cpp复制ListNode* removeNthFromEnd(ListNode* head, int n) {
    int pos = 0;
    return helper(head, n, &pos);
}

ListNode* helper(ListNode* node, int n, int* pos) {
    if (!node) return nullptr;
    node->next = helper(node->next, n, pos);
    (*pos)++;
    return *pos == n ? node->next : node;
}

5. 三种解法的性能对比

解法类型	时间复杂度	空间复杂度	适用场景	代码复杂度
两次遍历	O(2L)	O(1)	简单场景	简单
快慢指针	O(L)	O(1)	一般场景	中等
递归	O(L)	O(L)	短链表	简单

实际工程中选择建议：

内存受限环境：快慢指针
代码可读性优先：递归（确保链表不会过长）
教学演示：两次遍历（最易理解）

6. 常见错误与调试技巧

6.1 典型错误案例

空指针解引用：

cpp复制// 错误：未检查fast->next是否为空
while (fast) {  // 应该用fast->next
    fast = fast->next;
    slow = slow->next;
}

删除头节点处理不当：

cpp复制// 错误：直接返回head会导致头节点删除失败
if (count == n) {
    return head->next;  // 应该用dummy节点统一处理
}

递归版本忘记重置计数器：

cpp复制// 多次调用会导致count累积错误
int count = 0;  // 应该改为局部变量或类成员

6.2 调试技巧

可视化链表：

cpp复制void printList(ListNode* head) {
    while (head) {
        cout << head->val << "->";
        head = head->next;
    }
    cout << "NULL" << endl;
}

边界测试用例：

单节点链表删除唯一节点
删除头节点
删除尾节点
中等长度链表删除中间节点

内存泄漏检查（C++）：

cpp复制// 删除节点前保存指针
ListNode* toDelete = curr->next;
curr->next = curr->next->next;
delete toDelete;  // 如果节点是动态分配的

7. 工程实践中的扩展思考

7.1 双向链表版本

如果是双向链表，操作会更简单：

cpp复制void removeNthFromEnd(DListNode* head, int n) {
    DListNode* tail = head;
    while (tail->next) tail = tail->next;
    
    for (int i = 1; i < n; i++) {
        tail = tail->prev;
    }
    
    if (tail->prev) tail->prev->next = tail->next;
    if (tail->next) tail->next->prev = tail->prev;
    delete tail;
}

7.2 带环链表检测

实际工程中，应该先检测链表是否有环：

cpp复制bool hasCycle(ListNode* head) {
    if (!head) return false;
    ListNode *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) return true;
    }
    return false;
}

7.3 多语言实现差异

Python版本（无显式指针）：

python复制def removeNthFromEnd(head, n):
    dummy = ListNode(0, head)
    slow = fast = dummy
    for _ in range(n):
        fast = fast.next
    
    while fast.next:
        slow = slow.next
        fast = fast.next
    
    slow.next = slow.next.next
    return dummy.next

Java版本（垃圾回收）：

java复制public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode fast = dummy, slow = dummy;
    
    for (int i = 0; i < n; i++) 
        fast = fast.next;
    
    while (fast.next != null) {
        fast = fast.next;
        slow = slow.next;
    }
    
    slow.next = slow.next.next;
    return dummy.next;
}

8. 算法优化与变种问题

8.1 一次遍历找中间节点

类似技巧可以解决"找到链表中间节点"问题：

cpp复制ListNode* findMiddle(ListNode* head) {
    ListNode *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

8.2 删除所有倒数第N个节点

如果链表有重复值，要删除所有倒数第N个出现的值：

先用快慢指针找到位置
记录要删除的值
再次遍历删除所有该值节点

8.3 链表部分反转

结合反转链表技巧，可以实现更复杂的操作：

cpp复制void reverseBetween(ListNode* head, int m, int n) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode *pre = &dummy;
    
    for (int i = 1; i < m; i++) 
        pre = pre->next;
    
    ListNode *curr = pre->next;
    for (int i = m; i < n; i++) {
        ListNode *temp = curr->next;
        curr->next = temp->next;
        temp->next = pre->next;
        pre->next = temp;
    }
}

9. 系统设计中的应用案例

9.1 LRU缓存实现

LRU缓存淘汰算法需要频繁移动链表节点：

cpp复制class LRUCache {
    unordered_map<int, list<pair<int,int>>::iterator> cache;
    list<pair<int,int>> recent;
    int capacity;
    
    void touch(unordered_map<int, list<pair<int,int>>::iterator>::iterator it) {
        recent.splice(recent.begin(), recent, it->second);
    }
public:
    LRUCache(int capacity) : capacity(capacity) {}
    
    int get(int key) {
        auto it = cache.find(key);
        if (it == cache.end()) return -1;
        touch(it);
        return it->second->second;
    }
    
    void put(int key, int value) {
        auto it = cache.find(key);
        if (it != cache.end()) {
            touch(it);
            it->second->second = value;
            return;
        }
        
        if (cache.size() == capacity) {
            cache.erase(recent.back().first);
            recent.pop_back();
        }
        recent.emplace_front(key, value);
        cache[key] = recent.begin();
    }
};

9.2 文件系统块管理

文件系统常用链表管理空闲磁盘块，删除操作类似于释放磁盘空间：

cpp复制void freeBlock(BlockNode* head, BlockNode* target) {
    BlockNode* curr = head;
    while (curr->next != target) {
        curr = curr->next;
    }
    curr->next = target->next;
    addToFreeList(target);  // 加入空闲链表
}

10. 高频面试问题准备

面试中可能的相关问题：

如何检测链表是否有环？
如何反转链表？
如何合并两个有序链表？
如何找到两个链表的交点？
如何实现LRU缓存？

针对删除倒数第N个节点问题，面试官可能追问：

如果链表非常长，哪种方法最合适？
如何修改代码使其能处理N大于链表长度的情况？
如何测试这段代码？会设计哪些测试用例？
在分布式系统中，如何对超大链表进行这种操作？

我在实际面试中遇到过的一个变种问题是："如何在不修改链表结构的情况下，删除倒数第N个节点？" 这需要创建额外的数据结构来记录节点位置，或者多次遍历但不实际修改链表直到确定位置。