输入一个单向链表，输出逆序反转后的链表

可以使用迭代或递归的方式来实现单向链表的逆序反转。以下是使用迭代的方法：

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

def reverseList(head: ListNode) -> ListNode:
    prev = None
    curr = head
    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node
    return prev

以上代码中，我们使用了三个指针：prev、curr 和 next_node。prev 指向当前节点的前一个节点，curr 指向当前节点，next_node 指向当前节点的下一个节点。我们不断地将 curr 的 next 指针指向 prev，然后将 prev 和 curr 向后移动，直到 curr 为 None，此时 prev 就是反转后的链表的头节点。

例如，对于链表 1->2->3->4->5，反转后的链表为 5->4->3->2->1。

注意，以上代码中的 head 参数是链表的头节点，也就是第一个节点。如果链表为空，head 为 None。

相关问题

编程实现对一个单向链表的结点进行反转，也就是将链表结点按逆序排列，排序后链头将成为链尾，而链尾将成为链头。自定义函数名称及函数功能要求如下： （1）定义“createNode”函数，实现创建一个新结点。 （2）定义“createList”函数，实现一个单向链表的创建。 ● 在创建结点时通过键盘输入为每个结点的数据成员value进行赋值。 ● 使用“头插法”将每个结点逐一插入到链表中。 （3）定义“display”的函数，实现对链表所有结点的遍历输出。 （4）定义“reverse”的函数，实现对链表结点的反转 c语言

以下是对单向链表结点进行反转的C语言实现：

#include <stdio.h>
#include <stdlib.h>

// 定义单向链表结点结构体
typedef struct Node {
    int value;
    struct Node *next;
} Node;

// 创建新结点函数
Node *createNode(int value) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->value = value;
    newNode->next = NULL;
    return newNode;
}

// 创建单向链表函数
Node *createList(int n) {
    Node *head = NULL;
    for (int i = 0; i < n; i++) {
        int value;
        scanf("%d", &value);
        Node *newNode = createNode(value);
        newNode->next = head;
        head = newNode;
    }
    return head;
}

// 遍历输出链表函数
void display(Node *head) {
    Node *current = head;
    while (current != NULL) {
        printf("%d ", current->value);
        current = current->next;
    }
    printf("\n");
}

// 反转链表函数
Node *reverse(Node *head) {
    Node *prev = NULL;
    Node *current = head;
    while (current != NULL) {
        Node *next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    return prev;
}

int main() {
    int n;
    printf("请输入链表长度：");
    scanf("%d", &n);
    Node *head = createList(n);
    printf("原始链表：");
    display(head);
    head = reverse(head);
    printf("反转后链表：");
    display(head);
    return 0;
}

该程序中，createNode函数用于创建新的链表结点，createList函数用于创建单向链表，display函数用于遍历输出链表，reverse函数用于反转链表。

在main函数中，首先通过输入链表长度来创建单向链表，然后输出原始链表，将链表结点反转，最后输出反转后的链表。

输入一个正整数序列，遇负数时停止，建立一个线性链表存储读入的数据，将各个元素按逆序输出

当你输入一个正整数序列，遇到负数时操作会终止。在这种情况下，你可以通过创建一个单向链表数据结构来存储这些正整数。链表的每个节点包含一个整数值和指向下一个节点的指针。以下是实现这个功能的一般步骤：

1. 创建一个链表节点类，其中包含两个属性：值（value）和指向下一个节点的引用（next）。

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

2. 创建一个函数来添加新节点并处理输入流：

def add_to_list(n):
    if n < 0:
        return None
    else:
        new_node = ListNode(n)
        if not current_node:  # 链表为空，设置头节点
            head = new_node
        else:
            current_node.next = new_node
        current_node = new_node  # 更新当前节点
        return head

3. 初始化一个空链表和一个指向头节点的指针（current_node）：

head = None
current_node = None

4. 遍历输入流，调用 `add_to_list` 函数，并在遍历结束后反转链表输出：

input_sequence = [int(i) for i in input() if i > 0]  # 获取用户输入并过滤负数
reversed_list = reverse_linked_list(head)  # 反转链表

# 输出逆序的链表元素
while reversed_list:
    print(reversed_list.value)
    reversed_list = reversed_list.next

5. 写一个辅助函数 `reverse_linked_list` 来反转链表：

def reverse_linked_list(node):
    prev = None
    curr = node
    while curr:
        next_temp = curr.next
        curr.next = prev
        prev = curr
        curr = next_temp
    return prev