给定程序中，函数的功能是将带头结点的单向链表结点数据域中的数据从小到大排序。用C语言写

以下是一种可能的实现方式：

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

void sortLinkedList(Node* head) {
    Node* p1, * p2;
    int temp;
    for (p1 = head->next; p1 != NULL; p1 = p1->next) {
        for (p2 = p1->next; p2 != NULL; p2 = p2->next) {
            if (p1->data > p2->data) {
                temp = p1->data;
                p1->data = p2->data;
                p2->data = temp;
            }
        }
    }
}

其中，head 为带头结点的单向链表的头结点，p1 和 p2 为链表中的两个结点指针，temp 为临时变量用于交换数据。算法采用冒泡排序的思想，即从第一个结点开始，和后面的结点比较大小，如果前面的大于后面的，则交换数据，一直到链表结尾。时间复杂度为 O(n^2)。

相关问题

请用c语言写程序，在带头结点的双向循环链表中 元素x结点之后插入y。

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

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

void insertNode(Node *x, Node *y) {
    y->prev = x;
    y->next = x->next;
    x->next->prev = y;
    x->next = y;
}

int main() {
    // 创建带头结点的双向循环链表并初始化
    Node *head = (Node *)malloc(sizeof(Node));
    head->prev = head->next = head;
    head->data = -1;

    // 插入元素
    Node *x = head;
    while (x->next != head && x->data != 2) {
        x = x->next;
    }
    if (x->data == 2) {
        Node *y = (Node *)malloc(sizeof(Node));
        y->data = 5;
        insertNode(x, y);
    }

    // 输出链表
    x = head->next;
    while (x != head) {
        printf("%d ", x->data);
        x = x->next;
    }

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

    return 0;
}

注意事项：

1. 需要先遍历找到元素x所在的结点。
2. 插入的结点y需要动态分配内存。
3. 插入操作需要修改前驱和后继结点的指针。

c语言已知head指向一个带头结点的单向链表，链表中每个结点包含数据域（data）和指针域（next）。请编写函数实现链表的逆置。

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

其中，head为带头结点的单向链表头指针。首先定义prev和curr两个指针，分别指向前一个结点和当前结点。然后依次遍历链表，将当前结点的next指针指向前一个结点，然后将prev和curr向后移动，直到遍历完整个链表。最后将头指针的next指向反转后的链表的头结点。