编写程序建立一个带有头结点的单向链表，链表结点中的数据通过键盘输入，当输入0时，表示结束，实现数据的倒序输出

以下是Python语言实现的代码：

class Node:
    def __init__(self, data=None):
        self.data = data
        self.next = None

head = Node()  # 创建头结点
cur = head

while True:
    data = int(input("请输入一个整数："))
    if data == 0:
        break
    node = Node(data)
    cur.next = node
    cur = node

cur = head.next
stack = []

while cur:
    stack.append(cur.data)
    cur = cur.next

while stack:
    print(stack.pop(), end=" ")

思路说明：

1. 首先定义一个节点类 `Node`，包含数据域 `data` 和指针域 `next`；
2. 创建一个头结点 `head`；
3. 循环输入整数并创建新节点，将新节点插入到链表中；
4. 定义一个指针 `cur` 指向链表第一个节点，然后遍历整个链表，将每个节点的数据依次放入栈中；
5. 最后依次从栈中弹出元素并输出即可实现数据的倒序输出。

相关问题

用c语言编写程序建立一个带有头结点的单向链表，链表结点中的数据通过键盘输入，当输入0时，表示结束并使输出的数字与输入数字相反

以下是用C语言编写的带头结点的单向链表程序，可以实现输入一组数字，遇到0时倒序输出。

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

typedef struct Node {
    int data;
    struct Node* next;
} Node, *LinkedList;

// 初始化带头结点的单向链表
LinkedList initLinkedList() {
    LinkedList L = (LinkedList)malloc(sizeof(Node));
    L->next = NULL;
    return L;
}

// 向链表末尾添加结点
void appendNode(LinkedList L, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;

    Node* p = L;
    while (p->next != NULL) {
        p = p->next;
    }
    p->next = newNode;
}

// 遍历链表并逆序输出
void reverseOutput(LinkedList L) {
    if (L->next == NULL) {
        return;
    }
    Node* p = L->next;
    int arr[100];
    int i = 0;
    while (p != NULL) {
        arr[i++] = p->data;
        p = p->next;
    }
    for (int j = i - 1; j >= 0; j--) {
        printf("%d ", arr[j]);
    }
    printf("\n");
}

int main() {
    LinkedList L = initLinkedList();

    printf("请输入数字（以0结束）：\n");

    int data;
    scanf("%d", &data);
    while (data != 0) {
        appendNode(L, data);
        scanf("%d", &data);
    }

    reverseOutput(L);

    return 0;
}

在这个程序中，我们使用了带头结点的链表来存储数字，以便于在遍历链表时方便的处理头结点和普通结点。在输入数字时，我们通过循环读取输入的数字并将其添加到链表末尾。在输出时，我们先遍历链表并将其存储到一个数组中，然后再倒序输出数组中的元素。

要求用c语言编写程序建立一个带有头结点的单向链表，链表结点中的数据通过键盘输入，当输入0时，表示结束并使输出数字由大到小排列

好的，我可以帮你编写这个程序。首先，我们需要定义链表节点的结构体，包括数据域和指向下一个节点的指针域。同时，我们还需要定义一个头节点来方便链表的操作。

以下是完整的程序代码：

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

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

int main() {
    // 头节点初始化
    Node* head = (Node*)malloc(sizeof(Node));
    head->next = NULL;

    // 输入节点数据，直到输入0为止
    int num;
    do {
        printf("请输入一个整数（输入0结束）：");
        scanf("%d", &num);

        if (num != 0) {
            // 创建新节点并插入链表
            Node* new_node = (Node*)malloc(sizeof(Node));
            new_node->data = num;
            new_node->next = NULL;

            Node* cur = head;
            while (cur->next != NULL && cur->next->data > num) {
                cur = cur->next;
            }
            new_node->next = cur->next;
            cur->next = new_node;
        }
    } while (num != 0);

    // 遍历链表并按照从大到小输出节点数据
    Node* cur = head->next;
    printf("从大到小输出链表节点数据：");
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }

    // 释放链表内存
    cur = head;
    while (cur != NULL) {
        Node* temp = cur->next;
        free(cur);
        cur = temp;
    }

    return 0;
}

程序运行结果如下：

请输入一个整数（输入0结束）：3
请输入一个整数（输入0结束）：2
请输入一个整数（输入0结束）：5
请输入一个整数（输入0结束）：1
请输入一个整数（输入0结束）：4
请输入一个整数（输入0结束）：0
从大到小输出链表节点数据：5 4 3 2 1