c语言冒泡法实现对单链表排序

冒泡排序是一种简单的排序算法，可以用于对单链表进行排序。其基本思想是通过相邻元素的比较和交换，将较大的元素逐渐“冒泡”到链表的末尾。

下面是使用冒泡排序对单链表进行排序的C语言代码实现：

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

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

// 冒泡排序函数
void bubbleSort(struct ListNode *head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    
    int swapped;
    struct ListNode *ptr1;
    struct ListNode *lptr = NULL;
    
    do {
        swapped = 0;
        ptr1 = head;
        
        while (ptr1->next != lptr) {
            if (ptr1->val > ptr1->next->val) {
                // 交换节点的值
                int temp = ptr1->val;
                ptr1->val = ptr1->next->val;
                ptr1->next->val = temp;
                swapped = 1;
            }
            ptr1 = ptr1->next;
        }
        lptr = ptr1;
    } while (swapped);
}

// 创建链表节点
struct ListNode* createNode(int val) {
    struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
    newNode->val = val;
    newNode->next = NULL;
    return newNode;
}

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

int main() {
    // 创建链表
    struct ListNode *head = createNode(5);
    head->next = createNode(3);
    head->next->next = createNode(8);
    head->next->next->next = createNode(1);
    head->next->next->next->next = createNode(6);
    
    printf("排序前的链表：");
    printList(head);
    
    // 对链表进行冒泡排序
    bubbleSort(head);
    
    printf("排序后的链表：");
    printList(head);
    
    return 0;
}

以上代码中，我们首先定义了链表节点的结构体`struct ListNode`，然后实现了冒泡排序函数`bubbleSort`。在`bubbleSort`函数中，我们使用了两个指针`ptr1`和`lptr`，其中`ptr1`用于遍历链表，`lptr`用于记录已经排好序的部分的末尾节点。通过比较相邻节点的值，如果前一个节点的值大于后一个节点的值，则交换它们的值。通过多次遍历和交换，最终将较大的元素逐渐“冒泡”到链表的末尾。

在`main`函数中，我们创建了一个示例链表，并调用`bubbleSort`函数对链表进行排序。最后，打印排序前和排序后的链表。