链表的冒泡排序-没有头结点，交换链表节点

问题描述：

对一个没有头结点的链表进行冒泡排序，如果出现逆序交换链表的节点，而不是交换链表的值。

#include<iostream>
#include<vector>
#include<map>
#include<string>
using namespace std;
struct ListNode
{
    int val;
    ListNode * next;
    ListNode(int x) :val(x), next(NULL) {}
};
void BubbleSort(vector <int> &numbers, int n)
{
    for (int i = 0; i < n - 1; i++)
        for (int j = 0; j < n - 1 - i; j++)
            if (numbers[j] > numbers[j + 1])
                swap(numbers[j], numbers[j + 1]);
}
void PrintList(ListNode * pHead)
{
    while (pHead != NULL)
    {
        cout << pHead->val << endl;
        pHead = pHead->next;
    }
}
int GetLength(ListNode * pHead)
{
    int Length = 0;
    while (pHead != NULL)
    {
        ++Length;
        pHead = pHead->next;
    }
    return Length;
}
void ListBubbleSort(ListNode ** pHead)//由于没有头结点，所以链表的头结点可能被更改
{
    int n = GetLength(*pHead);
    ListNode * p1, *p2, *pPrev;
    for (int i = 0; i < n - 1; i++)//外层循环，控制冒泡排序进行几轮
    {
        p1 = *pHead;
        p2 = (*pHead)->next;
        pPrev = NULL;

        for (int j = 0; j < n - 1 - i; j++)//内层循环，控制从第一个节点开始进行遍历
        {
            if (p1->val > p2->val)
            {
                if (pPrev == NULL)//若需要交换的节点包括头结点
                {
                    ListNode * pTemp = p2->next;
                    p1->next = pTemp;
                    p2->next = p1;
                    *pHead = p2;
                    pPrev = p2;
                    p2 = pTemp;
                    continue;

                }
                else//若交换的节点不包括头结点
                {
                    ListNode * pTemp = p2->next;
                    pPrev->next = p2;
                    p2->next = p1;
                    p1->next = pTemp;
                    pPrev = p2;
                    p2 = pTemp;
                    continue;
                }
            }
            p1 = p1->next;
            p2 = p2->next;
            pPrev = pPrev->next;

        }
        PrintList(*pHead);
    }
}
int main()
{
    //没有写生成链表的函数，人工加了几个节点进行测试
    ListNode * pHead = new ListNode(3);
    ListNode * pNode2 = new ListNode(2);
    pHead->next = pNode2;
    
    ListNode * pNode3 = new ListNode(1);
    pNode2->next = pNode3;
    ListNode * pNode4 = new ListNode(0);
    pNode3->next = pNode4;

    PrintList(pHead);
    cout << GetLength(pHead) << endl;
    ListBubbleSort(&pHead);
    PrintList(pHead);

    
    


    return 0;
}