实现带头节点的单链表的逆置具体代码是什么样的

### 回答1：
单链表的逆置代码如下：

void reverseList(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    ListNode* prev = NULL;
    ListNode* curr = head->next;
    while (curr != NULL) {
        ListNode* next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    head->next = prev;
}

这段代码可以实现带头节点的单链表的逆置。

### 回答2：
实现带头节点的单链表的逆置的具体代码如下：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverseList(head):
    # 边界条件：链表为空或只有一个节点，直接返回头节点
    if not head or not head.next:
        return head

    # 使用三个指针pre、cur、next，分别指向前一个节点、当前节点、下一个节点
    pre = None
    cur = head.next
    while cur:
        next = cur.next
        cur.next = pre
        pre = cur
        cur = next

    # 将原头节点指向空，并返回反转后的头节点
    head.next = None
    head = pre

    return head

# 测试代码
# 创建链表
head = ListNode()
n1 = ListNode(1)
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
head.next = n1
n1.next = n2
n2.next = n3
n3.next = n4

# 反转链表
new_head = reverseList(head)

# 输出反转后的链表
p = new_head
while p:
    print(p.val)
    p = p.next

以上代码实现了带头节点的单链表的逆置。通过定义三个指针pre、cur、next，分别指向当前节点的前一个节点、当前节点和当前节点的下一个节点，进行链表的逆置操作。最后将原头节点指向空，并返回反转后的头节点。

### 回答3：
实现带头节点的单链表的逆置的具体代码如下：

#include <iostream>

using namespace std;

// 定义链表节点结构体
struct ListNode {
    int val;
    ListNode *next;
};

// 创建链表
ListNode *createLinkedList(int arr[], int n) {
    ListNode *head = new ListNode();  // 创建头节点
    ListNode *cur = head;  // 当前节点指针
    for (int i = 0; i < n; i++) {
        ListNode *newNode = new ListNode();
        newNode->val = arr[i];
        newNode->next = nullptr;
        cur->next = newNode;  // 将新节点链接到当前节点的后面
        cur = newNode;  // 使当前节点指针指向新节点
    }
    return head;
}

// 单链表逆置函数
ListNode *reverseLinkedList(ListNode *head) {
    if (head == nullptr || head->next == nullptr) {  // 链表为空或只有一个节点时直接返回
        return head;
    }
    ListNode *cur = head->next;  // 当前遍历的节点指针
    ListNode *pre = head;  // 当前节点的前一个节点指针
    ListNode *next = nullptr;  // 当前节点的后一个节点指针

    while (cur != nullptr) {
        next = cur->next;  // 保存下一个节点指针
        cur->next = pre;  // 将当前节点指向前一个节点
        pre = cur;  // 更新前一个节点指针
        cur = next;  // 更新当前节点指针
    }
    head->next = nullptr;  // 将原头节点指向null
    head = pre;  // 将头节点指向原链表的最后一个节点
    return head;
}

// 输出链表
void printLinkedList(ListNode *head) {
    ListNode *cur = head;
    while (cur->next != nullptr) {
        cur = cur->next;
        cout << cur->val << " -> ";
    }
    cout << "NULL" << endl;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    ListNode *head = createLinkedList(arr, n);
    cout << "原链表：";
    printLinkedList(head);
    cout << "逆置后的链表：";
    head = reverseLinkedList(head);
    printLinkedList(head);
    return 0;
}

以上代码首先定义了一个链表节点结构体ListNode，其中包含一个int类型的值和一个指向下一节点的指针。然后通过createLinkedList函数创建一个带头节点的单链表，并返回头节点；reverseLinkedList函数用于逆置链表，通过遍历链表并改变节点的next指针实现，最后将头节点指向逆置后的链表的最后一个节点。最后，通过printLinkedList函数输出链表。在main函数中，将递归调用这些函数创建链表并输出逆置后的链表。