编写一个c语言可执行算法（函数），把一个带头结点的单链表的倒置。

以下是一个基于迭代的 C 语言实现，假设链表的每个节点都是一个结构体类型 `Node`，其中 `next` 指针指向下一个节点：

Node* reverseLinkedList(Node* head) {
    if (!head || !head->next) {
        return head;
    }
    
    Node* pre = NULL;
    Node* cur = head->next;
    Node* nxt = NULL;
    
    while (cur) {
        nxt = cur->next;
        cur->next = pre;
        pre = cur;
        cur = nxt;
    }
    head->next = pre;
    return head;
}

我们首先判断链表是否为空或只有一个节点，如果是的话直接返回头结点。

接着定义三个指针，分别指向前驱节点、当前节点和后继节点。我们从头结点的下一个节点开始，一直迭代到链表末尾。在每次迭代中，我们先保存当前节点的下一个节点，然后将当前节点的 next 指针指向前驱节点，再更新前驱节点、当前节点和后继节点。最后我们更新头结点的 next 指针为倒置后的链表的头节点，并返回头结点。

以上是一个基于迭代的 C 语言实现，也可以使用递归实现。

相关问题

C语言假设线性表（a1,a2,a3,…an）采用带头结点的单链表存储，请设计算法函数将带头结点的单链表head就地倒置，使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试

下面是C语言的算法函数实现：

void reverseList(Node* head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    Node* prev = NULL;
    Node* curr = head->next;
    Node* next = NULL;
    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    head->next = prev;
}

其中，Node为单链表的节点类型，包含一个数据域和一个指向下一个节点的指针域。head为带头结点的单链表的头指针。

算法的实现思路是采用三个指针prev、curr和next，初始时prev为NULL，curr为头结点的下一个节点，next为NULL。然后每次将curr节点的next指针指向prev，然后将prev指针移动到curr所在的位置，将curr指针移动到next所在的位置，继续循环直到curr为NULL。最后将头结点的next指针指向prev即可。

以下是测试用例：

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

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

void reverseList(Node* head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    Node* prev = NULL;
    Node* curr = head->next;
    Node* next = NULL;
    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    head->next = prev;
}

void printList(Node* head) {
    if (head == NULL || head->next == NULL) {
        printf("List is empty.\n");
        return;
    }
    Node* p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

void test() {
    Node* head = (Node*)malloc(sizeof(Node));
    head->next = NULL;
    int n = 5;
    for (int i = 1; i <= n; i++) {
        Node* p = (Node*)malloc(sizeof(Node));
        p->data = i;
        p->next = head->next;
        head->next = p;
    }
    printf("原始链表：");
    printList(head);
    reverseList(head);
    printf("反转链表：");
    printList(head);
}

int main() {
    test();
    return 0;
}

输出结果：

原始链表：1 2 3 4 5 
反转链表：5 4 3 2 1 

1. 设计一个算法，将一个顺序表倒置。即，如果顺序表各个结点值存储在一维数组a中，倒置的结果是使得数组a中的a[0]等于原来的最后一个元素，a[1] 等于原来的倒数第2个元素，…，a的最后一个元素等于原来的第一个元素。（1）基本要求事先输入11,22,33,44,55这5个相应的结点，并输出。调用verge(L) 将顺序表倒置，然后输出。（2）参考算法思想算法verge(L)将一个顺序表倒置；函数原型：void verge(sequence_list *L)。从顺序表两端向中间遍历并交换。解：代码如下

以下是C语言实现的代码示例，实现了将一个顺序表倒置的功能：

#include <stdio.h>

#define MAXSIZE 100  // 定义数组的最大长度

typedef struct {
    int data[MAXSIZE];  // 用数组存储顺序表
    int length;  // 顺序表的长度
} sequence_list;

// 倒置顺序表
void verge(sequence_list *L) {
    int i, j, temp;
    for (i = 0, j = L->length - 1; i < j; i++, j--) {
        temp = L->data[i];
        L->data[i] = L->data[j];
        L->data[j] = temp;
    }
}

int main() {
    sequence_list L = {{11, 22, 33, 44, 55}, 5};  // 初始化顺序表
    int i;
    printf("原始顺序表：\n");
    for (i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
    verge(&L);  // 调用函数倒置顺序表
    printf("倒置后的顺序表：\n");
    for (i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
    return 0;
}

输出结果为：

原始顺序表：
11 22 33 44 55 
倒置后的顺序表：
55 44 33 22 11 

在这个示例中，定义了一个`sequence_list`结构体，用于存储顺序表。`verge`函数实现了顺序表的倒置，主函数中首先初始化了一个顺序表，并输出原始的顺序表。然后调用`verge`函数倒置顺序表，并输出倒置后的顺序表。