链表排序 ----- 冒泡排序和快速排序

冒泡排序

冒泡排序可能大家都普遍知道这里就不过多解释了，请看代码

void BubbleSort(ListNode* pHead)//冒泡排序  大到小
{
    ListNode* Next = NULL;
    ListNode* Cur = NULL;
    ListNode* pTail = NULL;
    int flag = 0;

    if (pHead == NULL || pHead->next == NULL)
        return;
    Cur = pHead;
    while (Cur != pTail)
    {
        flag = 0;
        while (Cur->next != pTail)
        {
            Next = Cur->next;
            if (Cur->data < Next->data)
            {
                DataType tmp = Cur->data;
                Cur->data = Next->data;
                Next->data = tmp;
                flag = 1;
            }
            Cur = Next;

        }
        if (flag == 0)
        {
            return;
        }
        pTail = Next;
        Cur = pHead;
    }
}

快速排序

快速排序是在遍历一遍链表后找到最大的元素与第一个元素进行信息交换，还有一种更加优化的方法是遍历一遍同时找到最大和最小两个元素分别与最两端的节点进行信息交换,请看代码

void QuickSort(ListNode* pHead)//快速排序
{
    ListNode* left = NULL;
    ListNode* right = NULL;
    ListNode* cur = NULL;
    int flag = 0;

    if (pHead == NULL || pHead->next == NULL)
        return;
    cur = pHead;
    left = pHead;

    while (cur->next != right && cur != right)
    {
        DataType max = left->data;
        DataType min = left->data;
        cur = left;
        while (cur->next != right)
        {
            cur = cur->next;
            if (max < cur->data)
            {
                max = cur->data;
                flag = 1;
            }
            if (min > cur->data)
            {
                min = cur->data;
            }
        }
        if (flag == 0)
            return;
        right = cur;
        left->data = max;
        right->data = min;
        cur = left;
        left = left->next;  
    }
}