链接列表上的冒泡排序的C程序

本程序使用C语言实现了在链表上进行冒泡排序的算法。链表是一种常见的数据结构，在很多应用中都得到了广泛的应用。冒泡排序是一种简单的排序算法，但是它的效率相对较低。

代码实现

本程序的代码如下：

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

#define ERROR 1e9

/* 链表结构体 */
typedef struct Node *PtrToNode;
struct Node {
    int value;
    PtrToNode next;
};

/* 创建链表 */
PtrToNode Create(int n)
{
    PtrToNode head = (PtrToNode)malloc(sizeof(struct Node));
    head->next = NULL;
    int cnt = 0;
    PtrToNode np = head;
    while (cnt < n) {
        int x;
        scanf("%d", &x);
        PtrToNode temp = (PtrToNode)malloc(sizeof(struct Node));
        temp->value = x;
        temp->next = NULL;
        np->next = temp;
        np = temp;
        cnt++;
    }
    return head;
}

/* 输出链表 */
void PrintList(PtrToNode head)
{
    PtrToNode np = head->next;
    while (np != NULL) {
        printf("%d ", np->value);
        np = np->next;
    }
    printf("\n");
}

/* 交换链表中的两个相邻节点 */
void SwapNode(PtrToNode root, PtrToNode prev)
{
    PtrToNode first = prev->next;
    PtrToNode second = first->next;
    if (second == NULL) return;
    PtrToNode next = second->next;
    prev->next = second;
    second->next = first;
    first->next = next;
}

/* 对链表进行冒泡排序 */
void BubbleSort(PtrToNode head)
{
    bool flag = true;
    PtrToNode root = (PtrToNode)malloc(sizeof(struct Node));
    root->next = head->next;
    head->next = root;
    PtrToNode prev = head;
    while (flag) {
        flag = false;
        PtrToNode np = root;
        while (np->next != NULL) {
            if (np->next->next == NULL) break;
            if (np->next->value > np->next->next->value) {
                SwapNode(root, np);
                flag = true;
            }
            np = np->next;
        }
        prev = np;
    }
    head->next = root->next;
    free(root);
}

/* 释放链表内存 */
void FreeList(PtrToNode head)
{
    PtrToNode np = head;
    while (np != NULL) {
        PtrToNode temp = np;
        np = np->next;
        free(temp);
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    PtrToNode head = Create(n);
    BubbleSort(head);
    PrintList(head);
    FreeList(head);
    return 0;
}

代码分析

本程序的代码主要分为以下几个部分：

创建链表

/* 创建链表 */
PtrToNode Create(int n)
{
    PtrToNode head = (PtrToNode)malloc(sizeof(struct Node));
    head->next = NULL;
    int cnt = 0;
    PtrToNode np = head;
    while (cnt < n) {
        int x;
        scanf("%d", &x);
        PtrToNode temp = (PtrToNode)malloc(sizeof(struct Node));
        temp->value = x;
        temp->next = NULL;
        np->next = temp;
        np = temp;
        cnt++;
    }
    return head;
}

该函数创建一个长度为n的链表，并返回链表的头指针。在函数内部，我们使用了一个计数器cnt来控制链表的长度，使用了一个指针np来表示链表的当前结点。

输出链表

/* 输出链表 */
void PrintList(PtrToNode head)
{
    PtrToNode np = head->next;
    while (np != NULL) {
        printf("%d ", np->value);
        np = np->next;
    }
    printf("\n");
}

该函数用于将链表中的元素输出到屏幕上，以空格分隔。

交换链表中的两个相邻节点

/* 交换链表中的两个相邻节点 */
void SwapNode(PtrToNode root, PtrToNode prev)
{
    PtrToNode first = prev->next;
    PtrToNode second = first->next;
    if (second == NULL) return;
    PtrToNode next = second->next;
    prev->next = second;
    second->next = first;
    first->next = next;
}

该函数用于交换链表中的两个相邻节点。在函数内部，我们首先获取第一个结点和第二个结点，然后进行交换。

对链表进行冒泡排序

/* 对链表进行冒泡排序 */
void BubbleSort(PtrToNode head)
{
    bool flag = true;
    PtrToNode root = (PtrToNode)malloc(sizeof(struct Node));
    root->next = head->next;
    head->next = root;
    PtrToNode prev = head;
    while (flag) {
        flag = false;
        PtrToNode np = root;
        while (np->next != NULL) {
            if (np->next->next == NULL) break;
            if (np->next->value > np->next->next->value) {
                SwapNode(root, np);
                flag = true;
            }
            np = np->next;
        }
        prev = np;
    }
    head->next = root->next;
    free(root);
}

该函数用于对链表进行冒泡排序。在函数内部，我们首先创建一个虚拟的根结点，将head指向该结点，然后对链表进行冒泡排序。在排序时，我们使用一个布尔变量flag来表示是否发生了交换操作。如果没有发生交换操作，说明链表已经有序，可以直接退出循环。在排序操作中，我们使用了SwapNode函数来进行结点的交换。

释放链表内存

/* 释放链表内存 */
void FreeList(PtrToNode head)
{
    PtrToNode np = head;
    while (np != NULL) {
        PtrToNode temp = np;
        np = np->next;
        free(temp);
    }
}

该函数用于释放链表占用的内存空间。

总结

本程序使用C语言实现了在链表上进行冒泡排序的算法。本程序不仅实现了链表的创建、输出、排序等功能，而且还演示了如何使用结构体、指针等C语言的高级特性。