c语言单链表的冒泡排序

单链表的冒泡排序可以通过交换节点的数据来实现。具体步骤如下：
1. 定义两个指针p和q，p指向链表的头节点，q指向p的下一个节点。
2. 遍历链表，比较p和q节点的数据，如果p的数据大于q的数据，则交换它们的数据。
3. 将指针p和q向后移动一个节点，继续比较并交换它们的数据，直到q指向链表的尾节点。
4. 如果在一轮遍历中没有进行任何数据交换，则说明链表已经有序，排序结束。
5. 重复以上步骤，直到链表完全有序。

下面是C语言单链表的冒泡排序代码实现：

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

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

// 创建链表
Node *createList(int arr[], int n) {
    Node *head = NULL, *p = NULL;
    for (int i = 0; i < n; i++) {
        Node *node = (Node *)malloc(sizeof(Node));
        node->data = arr[i];
        node->next = NULL;
        if (head == NULL) {
            head = node;
            p = head;
        } else {
            p->next = node;
            p = p->next;
        }
    }
    return head;
}

// 打印链表
void printList(Node *head) {
    Node *p = head;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 冒泡排序
void bubbleSort(Node *head) {
    int swapped = 1;
    while (swapped) {
        swapped = 0;
        Node *p = head, *q = head->next;
        while (q != NULL) {
            if (p->data > q->data) {
                int temp = p->data;
                p->data = q->data;
                q->data = temp;
                swapped = 1;
            }
            p = p->next;
            q = q->next;
        }
    }
}

int main() {
    int arr[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    Node *head = createList(arr, n);
    printf("排序前：");
    printList(head);
    bubbleSort(head);
    printf("排序后：");
    printList(head);
    return 0;
}