链表操作与LeetCode算法实战指南

1. 链表基础与LeetCode 203移除链表元素

链表作为数据结构中的基础类型，在实际工程和算法面试中出现的频率极高。与数组不同，链表通过指针将零散的内存块串联起来，这种非连续存储的特性带来了插入/删除的高效性（O(1)时间复杂度），但也牺牲了随机访问能力（O(n)时间复杂度）。

1.1 链表节点的标准实现

以C++为例，链表节点的经典定义如下：

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

这个简单的结构体包含两个关键元素：存储数据的val字段和指向下一个节点的next指针。构造函数将next初始化为nullptr（C++11中的空指针表示法），这是避免野指针的重要细节。

注意：在工程实践中，建议使用智能指针（如std::unique_ptr）替代裸指针，但在算法题中通常采用传统写法以保持代码简洁。

1.2 LeetCode 203问题解析

题目要求删除链表中所有值等于给定val的节点。看似简单的需求隐藏着几个关键陷阱：

1. 头节点处理：当需要删除的节点是头节点时，需要特殊处理
2. 连续目标节点：多个相邻节点都需要删除时容易遗漏
3. 尾节点处理：删除尾节点后需要正确置空前驱节点的next指针

1.3 双指针解法实现

最稳健的解法是使用双指针（pre和cur）遍历链表：

cpp复制ListNode* removeElements(ListNode* head, int val) {
    ListNode *dummy = new ListNode(0); // 虚拟头节点
    dummy->next = head;
    ListNode *pre = dummy, *cur = head;
    
    while (cur) {
        if (cur->val == val) {
            pre->next = cur->next;
            delete cur;    // 实际工程中需内存管理
            cur = pre->next;
        } else {
            pre = cur;
            cur = cur->next;
        }
    }
    ListNode *newHead = dummy->next;
    delete dummy;    // 释放虚拟头节点
    return newHead;
}

这个实现有几个值得注意的技术点：

• 使用dummy节点统一处理逻辑，避免头节点特殊判断
• 在删除节点时正确维护pre->next的指向
• 及时释放被删除节点的内存（面试中常被忽略）

实测中发现：在删除节点后，如果忘记将cur更新为pre->next，而是继续使用cur->next，当cur已被delete时会导致未定义行为。

2. LeetCode 707设计链表实现剖析

这道题要求实现一个完整的链表类，比单纯解题更能锻炼工程能力。我们需要处理各种边界条件，并保证所有操作的时空复杂度符合预期。

2.1 类设计要点

完整的MyLinkedList类应该包含：

cpp复制class MyLinkedList {
private:
    struct Node {
        int val;
        Node *next;
        Node(int x) : val(x), next(nullptr) {}
    };
    Node *head;
    int size;  // 维护长度避免遍历计算
    
public:
    MyLinkedList() : head(nullptr), size(0) {}
    
    // 各种成员函数实现...
};

维护size字段是很多初学者容易忽略的优化点。没有这个字段时，获取链表长度需要O(n)时间遍历，而维护它只需要O(1)时间。

2.2 关键操作的时间复杂度

2.3 添加节点的正确姿势

以addAtIndex为例，正确处理各种边界条件：

cpp复制void addAtIndex(int index, int val) {
    if (index > size) return;
    
    Node *newNode = new Node(val);
    if (index <= 0) {  // 头部插入
        newNode->next = head;
        head = newNode;
    } else {  // 中间或尾部插入
        Node *cur = head;
        for (int i = 0; i < index - 1; ++i) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
    }
    ++size;  // 勿忘更新长度
}

我在实际实现中发现：当index等于size时表示在尾部添加，这个边界条件经常被错误处理为无效索引。正确的做法是将其视为合法操作。

3. LeetCode 206反转链表的三种解法

反转链表是面试最高频的算法题之一，至少有五种经典解法。这里介绍最具代表性的三种实现方式。

3.1 迭代法（双指针）

这是最符合直觉的解法，通过两个指针逐步反转链表方向：

cpp复制ListNode* reverseList(ListNode* head) {
    ListNode *pre = nullptr, *cur = head;
    while (cur) {
        ListNode *next = cur->next;  // 临时保存
        cur->next = pre;  // 反转指向
        pre = cur;        // 移动pre
        cur = next;       // 移动cur
    }
    return pre;  // 新头节点
}

这个解法的时间复杂度是O(n)，空间复杂度是O(1)。关键点在于：

1. 需要临时保存cur->next，因为反转后会丢失原后继节点
2. 循环终止条件是cur为空，此时pre指向新头节点
3. 初始时pre设为nullptr，这是新链表的尾部

3.2 递归解法

递归版本更加简洁，但需要理解调用栈的工作原理：

cpp复制ListNode* reverseList(ListNode* head) {
    if (!head || !head->next) return head;
    
    ListNode *newHead = reverseList(head->next);
    head->next->next = head;  // 反转指向
    head->next = nullptr;     // 置空防止循环
    return newHead;
}

递归深度为链表长度n，因此空间复杂度是O(n)。在实际工程中，当链表很长时可能导致栈溢出，但在面试中展示这种解法能体现对递归的理解深度。

3.3 头插法

利用虚拟头节点，将原链表节点逐个插入到dummy之后：

cpp复制ListNode* reverseList(ListNode* head) {
    ListNode *dummy = new ListNode(0);
    ListNode *cur = head;
    
    while (cur) {
        ListNode *next = cur->next;
        cur->next = dummy->next;
        dummy->next = cur;
        cur = next;
    }
    
    ListNode *newHead = dummy->next;
    delete dummy;
    return newHead;
}

这种方法虽然多用了一个dummy节点，但在某些场景下更易于理解和扩展（比如反转部分链表）。

4. 链表操作实战技巧与调试方法

经过大量LeetCode链表题的实战，我总结出以下经验教训，能显著提高解题效率和正确率。

4.1 常见错误排查清单

当链表操作出现问题时，按此清单逐步检查：

1. 头尾节点处理：是否遗漏了头节点或尾节点的特殊情况？
2. 指针丢失：在修改next指针前是否保存了必要的信息？
3. 循环引用：反转或交换节点时是否意外创建了循环？
4. 空指针访问：是否对可能为null的指针进行了直接访问？
5. 长度维护：在增删操作后是否正确更新了链表长度？

4.2 可视化调试技巧

对于复杂的链表操作，在纸上画出节点和指针的变化过程非常有效。以反转链表为例：

初始状态：

code复制1 -> 2 -> 3 -> nullptr

第一次迭代后：

code复制nullptr <- 1  2 -> 3 -> nullptr
          pre cur

通过这种可视化方法，可以清晰看到每个步骤中指针的变化，避免逻辑错误。

4.3 边界条件测试用例

完善的测试应该包含这些边界情况：

• 空链表（nullptr）
• 单节点链表
• 全为相同值的链表
• 需要删除头节点或尾节点的情况
• 连续多个需要删除的节点

例如对LeetCode 203的测试：

cpp复制// 测试用例示例
TEST(RemoveElementsTest, EdgeCases) {
    Solution s;
    // 删除头节点
    ListNode *head1 = new ListNode(1);
    head1->next = new ListNode(2);
    ASSERT_EQ(s.removeElements(head1, 1)->val, 2);
    
    // 全删除
    ListNode *head2 = new ListNode(3);
    head2->next = new ListNode(3);
    ASSERT_EQ(s.removeElements(head2, 3), nullptr);
    
    // 空链表
    ASSERT_EQ(s.removeElements(nullptr, 1), nullptr);
}

4.4 内存管理注意事项

在C++实现中，特别需要注意：

1. 删除节点后立即将指针置空，避免悬垂指针
2. 使用delete释放new分配的内存
3. 考虑使用智能指针管理链表生命周期
4. 在递归解法中，注意深度过大导致的栈溢出

对于Java/Python等有垃圾回收的语言，虽然不用手动管理内存，但仍需注意对象引用关系，避免意外保持对不再需要节点的引用。