单链表的冒泡排序（C/C++实现）

前言

大家在做需要排名的项目的时候，需要把各种数据从高到低排序。如果用的冒泡排序的话，处理数组是十分简单的。因为数组的存储空间的连续的，可以通过下标就可以简单的实现。但如果是链表的话，内存地址是随机分配的，不能像数组那样通过下标就直接实现。所以在这里给大家介绍一个简单实现的冒泡排序。

冒泡排序

冒泡排序的是交换排序其中的一种，主要思想是每一个元素与后一个元素比较，若这个元素大于后一个元素，则交换这两个元素的位置（这里采用从小到大排序），第一次排序后最后一个数已经变成了最大数，再进行n - 2次排序即可完成（假设有n个数据）。代码如下:

void BubbleSort(int a[], int n)
{
    for(int i = 0; i < n - 1; i++)
    {
        for(int j = 0; j < n - i - 1; j++)
        {
            if(a[j] > a[j + 1])
            {
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

但这只适用于连续存储空间。对于链表来说，不太适用。所以接下来我将介绍一个比较简单的代码来实现链表的冒泡排序，代码如下（该链表是包含有头结点的，即第一个结点不放数据）：

// 进行冒泡排序
void BubbleSort(NODE* L)
{
    int count = 0;//记录链表结点的个数
    NODE* p, * q, * tail;//创建三个指针，进行冒泡排序
    p = L;
    while (p->next != NULL)//计算出结点的个数
    {
        count++;//注释①
        p = p->next;
    }
    for (int i = 0; i < count - 1; i++)//外层循环，跟数组冒泡排序一样
    {
        int num = count - i - 1;//记录内层循环需要的次数，跟数组冒泡排序一样，
        q = L->next;//令q指向第一个结点
        p = q->next;//令p指向第二个结点
        tail = L;//让tail始终指向q前一个结点，方便交换，也方便与进行下一步操作
        // 注释②
        while (num--)//内层循环,次数跟数组冒泡排序一样
        {
            if (q->data > p->data)//如果该结点的值大于后一个结点，则交换
            {
                q->next = p->next;
                p->next = q;
                tail->next = p;
            }
            // 进行指针的移动
            tail = tail->next;//注释③
            q = tail->next;//注释③
            p = q->next;//注释③
        }
    }
}

注释①：
因为通常情况下来说，我们都不知道链表的结点个数，所以需要去计算出来作为循环的次数。如果已知的话，可以直接传入参数作为count。注释①的while循环就可以去掉了。
注释②：
在内存循环的while(num--)条件可以换为while(p != NULL)来判断，文章中使用 num--做为判断条件是为了和冒泡排序的内层循环次数一致。
注释③
这里为什么要采用tail作为下一步操作的重要点呢，因为如果直接通过p，和q操作，很容易重复循环了，但如果通过tail进行操作的话，结点始终不会有问题。
刚开始结点排序如下：

当排序完成后，进行tail = tail- >next；此时tail就是下一个结点，p和q只要按照tail的结点走，就不会出问题。
图示如下：

所以我们借用tail这个结点，就可以达到跟数组的冒泡排序一样的操作。

可运行代码：

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

// 自定义的结构体，用来存储链表的内容
typedef struct node
{
    int data; // 数据域
    struct node* next; // 指针域
}NODE;//别名

// 给链表新增节点
void add(NODE* head, int data)
{
    NODE* p = (NODE*)malloc(sizeof(NODE));// p 为新增的结点
    NODE* L = head;//，L为当前链表的最后一个结点
    while (L->next != NULL)//当L->next == NULL的时候，就代表是L是最后一个结点
    {
        L = L->next;
    }
    p->data = data;//把值赋给p中的data域
    p->next = NULL; // 初始化操作，p是最后一个节点，故没有下一个节点了，因此next指针域需要指向NULL
    L->next = p;//把新创建的结点加入到当前链表中
}

// 进行冒泡排序
void BubbleSort(NODE* L)
{
    int count = 0;//记录链表结点的个数
    NODE* p, * q, * tail;//创建三个指针，进行冒泡排序
    p = L;
    while (p->next != NULL)//计算出结点的个数
    {
        count++;//注释①
        p = p->next;
    }
    for (int i = 0; i < count - 1; i++)//外层循环，跟数组冒泡排序一样
    {
        int num = count - i - 1;//记录内层循环需要的次数，跟数组冒泡排序一样，
        q = L->next;//令q指向第一个结点
        p = q->next;//令p指向第二个结点
        tail = L;//让tail始终指向q前一个结点，方便交换，也方便与进行下一步操作
        while (num--)//内层循环,次数跟数组冒泡排序一样
        {
            if (q->data > p->data)//如果该结点的值大于后一个结点，则交换
            {
                q->next = p->next;
                p->next = q;
                tail->next = p;
            }
            // 进行指针的移动
            tail = tail->next;//注释②
            q = tail->next;//注释②
            p = q->next;//注释②
        }
    }
}

int main()
{
    NODE* head = (NODE*)malloc(sizeof(NODE));//定义头结点
    head->next = NULL; //当前链表无下一个节点，因此next指针域需要指向NULL
    int n;//链表的长度
    printf("请输入链表的长度: ");
    scanf("%d", &n);

    printf("请输入链表中的数字: ");
    for (int i = 0; i < n; i++)
    {
        int x;//每一个结点的值
        scanf("%d", &x);
        add(head, x);//向链表追加结点
    }

    BubbleSort(head);//进行冒泡排序

    NODE* p = head->next;//因为第一个结点没有存放数据，所以从第二个结点开始输出
    while (p != NULL)
    {
        printf("%d\t", p->data);
        p = p->next;
    }

    return 0;
}

如果有疑问和见解，欢迎大家提出来一起分享。（新手作文，写的不太明白，见谅见谅~）

**

温馨提示：第一个结点不是用来放数据的，是用来辅助完成排序的。

**