已知链表的头结点head,写一个函数把这个链表逆序，详解与示例

---

链表是数据结构中常见的一种，它的每个节点都包含数据和指向下一个节点的指针。逆序链表是链表操作中的一个基本问题，目的是将链表中的节点顺序反转。以下是一个详细的博客，介绍如何在 C/C++ 中实现链表的逆序功能。

1. 链表结构定义

首先，我们需要定义链表节点的结构。在 C/C++ 中，通常使用结构体来定义链表节点：

// 定义链表节点
struct ListNode {
    int val;          // 节点值
    ListNode* next;   // 指向下一个节点的指针
    
    // 构造函数
    ListNode(int x) : val(x), next(nullptr) {}
};

2. 逆序链表的算法

逆序链表的基本思路是通过调整节点的指针方向来实现。我们需要三个指针来完成这一操作：

• prev：指向前一个节点
• curr：指向当前节点
• next：暂存当前节点的下一个节点

具体步骤如下：

1. 初始化 prev 为 nullptr，curr 为 head。
2. 遍历链表，直到 curr 为 nullptr：
3. 保存 curr->next 到 next。
4. 将 curr->next 指向 prev。
5. 移动 prev 和 curr 指针。
6. 最终，prev 将成为新链表的头节点。

下面是逆序链表的 C++ 实现代码：

// 逆序链表函数
ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;  // 初始化前一个节点为空
    ListNode* curr = head;     // 当前节点指向链表的头节点
    ListNode* next = nullptr;  // 临时节点
    
    while (curr != nullptr) {
        next = curr->next;   // 保存下一个节点
        curr->next = prev;   // 反转当前节点的指针
        prev = curr;         // 移动前一个节点指针
        curr = next;         // 移动当前节点指针
    }
    
    return prev;  // 返回新的头节点
}

3. 示例

为了更好地理解，我们可以创建一个示例链表并应用逆序操作：

#include <iostream>

using namespace std;

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

// 逆序链表函数
ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* curr = head;
    ListNode* next = nullptr;
    
    while (curr != nullptr) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    
    return prev;
}

// 打印链表
void printList(ListNode* head) {
    ListNode* temp = head;
    while (temp != nullptr) {
        cout << temp->val << " ";
        temp = temp->next;
    }
    cout << endl;
}

// 主函数
int main() {
    // 创建一个链表 1 -> 2 -> 3 -> 4 -> 5
    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);

    cout << "Original List: ";
    printList(head);

    // 逆序链表
    ListNode* reversedHead = reverseList(head);

    cout << "Reversed List: ";
    printList(reversedHead);

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

    return 0;
}

注意事项

1. 逆序链表时，我们需要小心处理指针，以避免链表断裂或内存泄漏。
2. 在实际应用中，如果链表很长，逆序操作可能会对性能产生影响，因为它的时间复杂度是O(n)。
3. 如果链表为空或者只有一个结点，逆序操作将不会改变链表。

4. 总结

逆序链表是一项经典的链表操作，其核心在于调整节点的指针方向。通过使用三个指针（prev、curr、next），我们可以有效地将链表逆序。以上代码展示了如何在 C++ 中实现这一操作，并通过一个简单的示例验证了结果。