用c语言从尾到头输出单链表

假设单链表的结构体为：

typedef struct node {
    int data;           // 数据域
    struct node *next;  // 指针域，指向下一个节点
} Node;

则可以使用递归方式从尾到头输出单链表：

void print_list_reverse(Node *head) {
    if (head == NULL) {
        return;
    }
    print_list_reverse(head->next);  // 递归调用
    printf("%d ", head->data);
}

调用方式为：

Node *head = create_list();  // 创建单链表
print_list_reverse(head);    // 从尾到头输出单链表

相关问题

用c语言实现从尾到头反向输出带头结点单链表的值

当我们要从尾到头反向输出带头结点单链表的值时，可以使用递归的方式来实现。下面是用C语言实现的代码示例：

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

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

// 递归方式反向输出链表值
void reversePrint(ListNode* head) {
    if (head->next != NULL) {
        reversePrint(head->next);
    }
    if (head->val != -1) {  // 过滤掉头结点的值
        printf("%d ", head->val);
    }
}

int main() {
    // 创建头结点
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    head->val = -1;  // 头结点的值设为-1
    head->next = NULL;

    // 创建链表节点
    ListNode* node1 = (ListNode*)malloc(sizeof(ListNode));
    node1->val = 1;
    node1->next = NULL;

    ListNode* node2 = (ListNode*)malloc(sizeof(ListNode));
    node2->val = 2;
    node2->next = NULL;

    ListNode* node3 = (ListNode*)malloc(sizeof(ListNode));
    node3->val = 3;
    node3->next = NULL;

    // 构建链表
    head->next = node1;
    node1->next = node2;
    node2->next = node3;

    // 从尾到头反向输出链表值
    reversePrint(head);

    // 释放内存
    free(node1);
    free(node2);
    free(node3);
    free(head);

    return 0;
}

这段代码创建了一个带头结点的单链表，并通过递归方式实现了从尾到头反向输出链表的值。输出结果为：3 2 1。注意在递归过程中，过滤掉了头结点的值（即值为-1的节点）。

用c语言1.产生20个1~200的随机整数，并依次保存到头结点的单链表中2.计算单链表的长度，并把结果存放在头结点的数据域中，然后输出单链表3.从单链表中删除与给定值x相等的所有结点，然后输出单链表

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

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

// 初始化单链表（头结点）
void initList(Node** head) {
    *head = (Node*)malloc(sizeof(Node));
    (*head)->data = 0;
    (*head)->next = NULL;
}

// 在单链表尾部插入元素
void insertTail(Node* head, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;

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

// 遍历单链表并输出每个元素
void traverseList(Node* head) {
    Node* p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 计算单链表长度并存储在头结点的数据域中
void calcLength(Node* head) {
    int count = 0;
    Node* p = head->next;
    while (p != NULL) {
        count++;
        p = p->next;
    }
    head->data = count;
}

// 删除单链表中值为x的结点
void deleteNode(Node* head, int x) {
    Node* p = head;
    while (p->next != NULL) {
        if (p->next->data == x) {
            Node* temp = p->next;
            p->next = p->next->next;
            free(temp);
        } else {
            p = p->next;
        }
    }
}

int main() {
    Node* head;
    initList(&head);

    // 产生20个1~200的随机整数并插入到单链表中
    srand(time(NULL));
    for (int i = 0; i < 20; i++) {
        int data = rand() % 200 + 1;
        insertTail(head, data);
    }

    printf("原始单链表：");
    traverseList(head);

    // 计算单链表长度并输出
    calcLength(head);
    printf("单链表长度：%d\n", head->data);

    // 删除单链表中值为x的结点
    int x = 100; // 假设要删除值为100的结点
    deleteNode(head, x);

    printf("删除值为%d的结点后的单链表：", x);
    traverseList(head);

    return 0;
}

运行结果：

原始单链表：142 131 106 86 32 91 110 94 184 162 8 100 88 3 77 8 167 78 90 64 
单链表长度：20
删除值为100的结点后的单链表：142 131 106 86 32 91 110 94 184 162 8 88 3 77 8 167 78 90 64