设计一个算法，将带头结点的单链表逆置。

算法如下：

1. 定义三个指针：pre指向当前节点的前一个节点，cur指向当前节点，next指向当前节点的下一个节点。

2. 将头结点的next指针置为NULL，表示逆置后的链表的尾节点。

3. 从头结点的下一个节点开始，依次遍历链表。

4. 对于每个节点，将其next指针指向pre节点，实现逆置。

5. 更新pre、cur、next指针，继续遍历链表。

6. 遍历结束后，将头结点的next指针指向pre节点，表示逆置后的链表的头节点。

7. 返回逆置后的链表头节点。

具体实现可以参考以下代码：

ListNode* reverseList(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    ListNode* pre = NULL;
    ListNode* cur = head->next;
    ListNode* next = cur->next;
    head->next = NULL;
    while (next != NULL) {
        cur->next = pre;
        pre = cur;
        cur = next;
        next = next->next;
    }
    cur->next = pre;
    head->next = cur;
    return head;
}

相关问题

设计一个算法，将带头结点的单链表逆置

算法步骤如下：

1. 定义三个指针：p、q、r，分别指向头结点、第一个结点和第二个结点。

2. 将p的next指针指向NULL，表示逆置后的链表的尾结点。

3. 循环遍历链表，每次将q的next指针指向p，表示将当前结点逆置。

4. 将p、q、r指针向后移动一个结点，继续遍历链表。

5. 当r指针指向NULL时，表示遍历完整个链表，逆置完成。

6. 将头结点的next指针指向q，表示逆置后的链表的头结点。

具体实现可以参考以下代码：

void reverseList(Node* head) {
Node *p = head, *q = head->next, *r = q->next;
p->next = NULL;
while (r != NULL) {
q->next = p;
p = q;
q = r;
r = r->next;
}
q->next = p;
head->next = q;
}

用c语言设计一个算法，将带头的单链表逆置

在 C 语言中，我们可以使用迭代的方式来设计一个简单算法来逆置带头结点的单链表。这里是一个基本的步骤：

1. 定义两个指针，`prev` 和 `current`，初始时都指向头节点。
2. 当 `current` 指针不为空时，进行循环操作：
- 将 `current` 的下一个节点赋值给 `temp`（临时存储当前节点的下一个节点）
- 更新 `current` 的下一个节点为 `prev`
- 移动 `prev` 和 `current` 向前，即 `prev = current`, `current = temp`
3. 循环结束后，`prev` 就指向了新的头节点。

下面是对应的伪代码和 C 语言代码实现：

// 结构体定义链表节点
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 函数定义逆置链表
Node* reverseList(Node* head) {
    Node* prev = NULL; // 初始化prev为NULL
    Node* current = head; // 初始化current为头节点

    while (current != NULL) { // 当current非空时
        Node* temp = current->next; // 保存当前节点的下一个
        current->next = prev; // 更新当前节点的next为prev
        prev = current; // 移动prev
        current = temp; // 移动current
    }
    return prev; // 返回新头节点
}