基于无头节点的单链表的升序冒泡排序（C++实现）

  由于基础代码的特殊（链表为无头链表），以下冒泡排序算法采用两种方式进行排序。首先对首节点往后的所有节点进行排序，这里使用的是对其索引顺序改变的方法。然后对首节点进行排序，只需要一次循环即可，这里使用的是对节点中的数值进行交换的方法。

---

#include <iostream>
using namespace std ;

#define ERROR -1
#define CORRECT 1

//定义
struct LNode {
    int data ;
    LNode *next ;
} ;
LNode *LinkList ;

//查找
LNode *SearchLinkList (LNode *L , int i)
{
    int j ;
    LNode *p ;

    p = L ;
    j = 1 ;
    while (p &&j < i)
    {
        p = p -> next ;
        j++ ;
    }
    if (!p || j>i)
    {
        return (p) ;
    }
}

//插入
int InsertLinkList (LNode *L , int e , int i)
{
    //在链表L中第i个位置插入元素e
    LNode *p , *s ;
    p = SearchLinkList (L , i-1) ;
    if (!p) 
    {
        return (ERROR) ;
    }
    s = new LNode ;
    //节点插入L中
    s -> data = e ;
    s -> next = p -> next ;
    p -> next = s ;

    return (CORRECT) ;
}

//表单创建
LNode *CreateLinkList (int *r , int n)
{
    int j ;
    LNode *L , *p , *s ;

    if (n <= 0)
    {
        return (NULL) ;
    }
    s = new LNode ;
    s -> data = r[1] ;
    s -> next = NULL ;
    L = s ;
    p = L ;
    for (j = 2 ; j <= n ; j++)
    {
        /*
        s = new LNode ;
        s -> data = r[j] ;
        s -> next = NULL ;
        p -> next = s;
        p = s ;
        */

        InsertLinkList (L , r[j] , j) ;
    }
    return (L) ;
}

//删除
int DeleteLinkList (LNode *L , int i)
{
    //在表中删除第i个位置
    int e ;
    LNode *p , *q ;

    p = SearchLinkList (L , i-1) ;
    if (!p)
    {
        return (ERROR) ;
    }
    q = p -> next ;
    p -> next = p -> next -> next ;    //不可用q，因为q是用来指示将要删除的内存
    e = q -> data ;
    delete (q) ;

    return (e) ;
}

//结果输出
int ShowLinkList (LNode *L)
{
    LNode *p ;

    if (!L)
    {
        return (ERROR) ;
    }
    p = L ;
    while (p -> next)
    {
        cout << p -> data <<" " ;
        p = p -> next ;
    }
    cout << p -> data << endl ;
    return (CORRECT) ;
}

//升序排序(完全用指针操作，有bug)
int BubbleSortPoint (LNode *L)
{
    LNode *HeadNode ;
    HeadNode = new LNode ;

    LNode *p ;
    LNode *q ;

    LNode *a1 ;
    LNode *a2 ;
    LNode *a3 ;
    if (!L)
    {
        return (ERROR) ;
    }

    HeadNode -> next = L ;    //增加头节点

    cout << "HeadNode ->next ->data = " <<HeadNode ->next->data << endl; //打印调试
    
    /*由于链表L为无头节点链表，故先对首节点数据进行处理*/

    for (p = HeadNode ; p -> next != NULL ; p = p -> next)
    {
        for (q = HeadNode; q -> next -> next != NULL ; q = q -> next)
        {
            /*节点指针*/
            a1 = q -> next ;
            a2 = q -> next -> next ; 
            a3 = q -> next -> next -> next ;
            
            /*打印调试*/
            cout << "a1 -> data = " <<a1->data << endl ;
            cout << "a2 -> data = " <<a2->data << endl ;
            if (a3!=NULL)
            {
                cout << "a3 -> data = " <<a3->data << endl ;
            }
            else
            {
                cout << "a3 -> data = NULL" <<endl ;
            }

            cout <<endl;

            /*打印调试*/
            if (a1 -> data > a2 -> data)
            {
                /*节点交换*/
                q -> next = a2 ;
                a2 -> next = a1 ;
                a1 -> next = a3 ;
            }
        }
    }

    //对首节点进行处理
    cout << "HeadNode -> next -> data = " << HeadNode -> next -> data << endl ;
    p = L ;
    L = HeadNode -> next ;
    cout << "L -> data = " << L -> data << endl ;
    cout << "L -> next -> data = " << L -> next ->data << endl ;
    cout << "L -> next -> next -> data = " << L -> next -> next ->data << endl ;
    cout << "L -> next -> next -> next -> data = " << L -> next -> next -> next ->data << endl ;
    cout << "L -> next -> next ->next -> next -> data = " << L -> next -> next -> next -> next ->data << endl ;

    return (CORRECT) ;
}

//升序冒泡排序(指针与data交换结合)
int BubbleSort (LNode *L)
{
    LNode *p ;
    LNode *q ;
    int middleData ; //中间数据，用于实现首节点数据的沉底操作

    /*用于节点索引顺序交换操作的指针定义*/
    LNode *a1 ;
    LNode *a2 ;
    LNode *a3 ;

    if (!L)
    {
        return (ERROR) ;
    }

    
    /*先用指针索引更改的方式排序首节点以后的元素*/

    for (p = L ; p -> next != NULL ; p = p -> next)
    {
        for (q = L ; q -> next -> next != NULL ; q = q -> next)
        {
            /*节点指针*/
            a1 = q -> next ;
            a2 = q -> next -> next ; 
            a3 = q -> next -> next -> next ;
            
            if (a1 -> data > a2 -> data)
            {
                /*节点交换*/
                q -> next = a2 ;
                a2 -> next = a1 ;
                a1 -> next = a3 ;
            }
        }
    }

    /*再对首节点数据采取数值交换的方式使其沉底*/
    p = L ;
    while (p -> next)
    {
        if (p -> data > p -> next -> data)
        {
            middleData = p -> data ;
            p -> data = p -> next -> data ;
            p -> next -> data = middleData ;
        }
        p = p -> next ;
    }

    return (CORRECT) ;

}

int main (int argc , char * argv[])
{
    int r[100] , i ,SampleNum , SearchPos , NewPos , NewItem , DelPos ;
    LNode *p ;

    cin >> SampleNum ;
    for (i = 1 ; i <= SampleNum ; i++)
    {
        cin >> r[i] ;
    }
    LinkList = CreateLinkList (r , SampleNum) ;
    ShowLinkList (LinkList) ;

    cout << "冒泡排序：" << endl ;
    BubbleSort (LinkList) ;
    ShowLinkList (LinkList) ;

    cin >> SearchPos ;
    p = SearchLinkList (LinkList , SearchPos) ;
    cout << p -> data << endl ;

    cin >> NewPos ; 
    cin >> NewItem ;
    InsertLinkList (LinkList , NewItem , NewPos) ;
    ShowLinkList (LinkList) ;

    cin >> DelPos ;
    DeleteLinkList (LinkList , DelPos) ;
    ShowLinkList (LinkList) ;

    return 0;
}