试写一算法，实现单链表上的冒泡排序。

 试写一算法，实现单链表上的冒泡排序。

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

#define OK 1
#define ERROR 0

typedef char Status;
typedef char ElemType;

//链表结构体、指向链表的指针
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode,*LinkList;

Status InitList(LinkList &L);
Status CreatList(LinkList &L, int n, ElemType Data[]);
Status SortL(LinkList &L);
void OutputL(LinkList &L);
void BubbleSort(LinkList &L);

//试写一算法，删除元素非递减排列的单链表L中所有值相同的元素,即相同元素值只保留一个
int main()
{
    LinkList L;
    ElemType a[22] = {"y6Z27X9AcBz1C3b458aYx"};

    InitList(L);
    CreatList(L,22,a);
    printf("原表:\n");
    OutputL(L);//输出原表

    SortL(L);
    //BubbleSort(L);//与前一句的效果一样
    printf("\n排序后:\n");
    OutputL(L);
    return 0;

}

//初始化单链表
Status InitList(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode)); /*产生头结点,并使L指向此头结点*/
    if(!(L))
        return ERROR;
    (L)->next=NULL;
    return OK;
}

//尾插法创建单链表
Status CreatList(LinkList &L,int n,ElemType Data[])
{
    LinkList s,r;
    int i;

    if(!L || L->next)
        return ERROR;
    for(i=0, r=L; i<n; i++)
    {
        s=(LinkList)malloc(sizeof(LNode));
        if(!s)
            return ERROR;

        s->data =Data[i];

        s->next = r->next;
        r->next = s;                      /*将尾结点的指针指向新结点 */
        r = r->next;                         /*将当前的新结点定义为新的尾结点*/
    }
    return OK;
}

//输出单链表
void OutputL(LinkList &L)
{
    LinkList p;
    if(L)
    {
        p=L->next;
        while(p)
        {
            printf("%c ",p->data );
            p=p->next;
        }
    }
}
//在数据域操作进行冒泡排序
Status SortL(LinkList &L)
{
    LinkList p,q;
    for(p = L->next; p->next; p = p->next)
    {
        for(q = L->next; q->next; q = q->next)
        {
            if(q->data > q->next->data)
            {
                ElemType temp = q->data;
                q->data = q->next->data;
                q->next->data = temp;
            }
        }
    }
    return OK;
}

//在指针域操作进行冒泡排序
void BubbleSort(LinkList &L)
{
    int i,cnt = 0, num; //cnt记录链表结点的个数，num进行内层循环
    LinkList p,q,tail;//创建三个指针，进行冒泡排序
    for(p= L; p->next; p = p->next) //计算出结点的个数
        cnt++;
    for(i = 0; i < cnt - 1; i++)//外层循环，跟数组冒泡排序一样
    {
        num = cnt - 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;
        }
    }
}