头插法实现链表逆置

链表逆置是将链表中的节点顺序颠倒。头插法是链表逆置的一种常用方法。具体实现步骤如下：

1. 定义一个新的链表头结点 `new_head`，并初始化为空。
2. 遍历原链表的每一个节点，将其插入到新链表的头部，使其成为新链表的第一个节点。
3. 最终得到的新链表就是反转后的链表。

以下是头插法实现链表逆置的 C++ 代码：

ListNode* reverseList(ListNode* head) {
    ListNode* new_head = NULL;  // 定义新链表头结点并初始化为空
    while (head != NULL) {
        ListNode* next = head->next;  // 保存下一个节点
        head->next = new_head;  // 将当前节点插入到新链表头部
        new_head = head;  // 更新新链表头结点
        head = next;  // 处理下一个节点
    }
    return new_head;  // 返回反转后的链表头结点
}

需要注意的是，在实际使用中，还需要考虑链表为空的情况。

相关问题

使用头插法实现链表逆置C语言

头插法是一种常用的链表逆置算法，它通过不断将当前遍历到的节点插入到链表的头部来实现链表的逆置。

以下是实现头插法逆置链表的 C 语言代码：

struct node {
    int data;
    struct node *next;
};

struct node* reverseList(struct node *head) {
    struct node *prev = NULL, *curr = head, *next = NULL;
    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

在代码中，我们定义了一个名为 `node` 的结构体，用于存储链表中的节点。在 `reverseList` 函数中，我们使用三个指针 `prev`、`curr` 和 `next` 实现头插法，通过不断更新这三个指针的值，从而实现链表的逆置。最后，返回逆置后的链表的头节点。

用头插法实现链表逆置c++

头插法是一种常见的链表逆置算法，它通过不断将当前节点插入到已反转链表的头部来达到逆序的效果。以下是使用C++实现头插法链表逆置的基本步骤：

#include <iostream>

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

// 使用头插法逆置链表
ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr; // 初始化前驱指针为空
    ListNode* current = head; // 初始化当前指针指向头结点

    while (current != nullptr) { // 当链表非空时
        ListNode* nextTemp = current->next; // 保存下一个节点
        current->next = prev; // 将当前节点的next指向前驱
        prev = current; // 更新前驱指针为当前节点
        current = nextTemp; // 移动当前指针到下一个节点
    }
    
    return prev; // 返回新的头节点，即原链表的尾部
}

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

int main() {
    // 创建一个示例链表
    ListNode* list = new ListNode(1);
    list->next = new ListNode(2);
    list->next->next = new ListNode(3);
    list->next->next->next = new ListNode(4);

    std::cout << "Original List:" << std::endl;
    printList(list);

    // 逆置链表
    list = reverseList(list);

    std::cout << "Reversed List:" << std::endl;
    printList(list);

    return 0;
}

在这个例子中，`reverseList`函数接收一个链表头节点作为输入，通过遍历链表并将每个节点的next指针指向前一个节点，实现了链表的逆序。