自底向上的归并排序算法——链表排序

本篇文章主要是使用归并排序算法对链表进行排序，本文的代码大量参考了liuyubobobo老师的课程代码（ps:用归并排序算法实现链表排序其实是liuyubobobo老师课程的选作作业）

请注意，本人并不是大佬，只是个初学者，因此代码质量可能不会让你满意，仅供参考。

完整代码如下，实际上最核心的函数是mergeSortBUList，__mergeList，要看归并排序的实现就看这两个函数即可，其他函数都是用来验证排序的正确性和生成随机链表。

#include<iostream>
#include<ctime>
#include<cassert>
using namespace std;

class node
{
public:
    int data;
    node *next;//指向下一个节点的地址
};

class list
{
public:
    node *head;//头节点的位置
    int size;//链表的长度
};

list* list_init()
{
    //创建一个空链表，仅包含一个无数据的空节点
    list *L=new list;
    L->size=0;
    L->head=new node;
    L->head->data=NULL;
    L->head->next=NULL;
    return L;
}


void listInsert(list *L,int pos,int data)//pos从0开始
{
    if(L->size==0)//链表此时没有节点，直接把数据放入第一个空节点
    {
        L->head->data=data;
        L->size++;
        return;
    }

    if(pos > L->size)
        pos=L->size;

    node* insertNode=new node;
    insertNode->data=data;
    if(pos==0)//在头节点前插入一个节点
    {
        insertNode->next=L->head;
        L->head=insertNode;
        L->size++;
        return;
    }

    node* temp=L->head;
    for(int i=0;i<pos-1;i++)
        temp=temp->next;//temp一直去到要插入位置的前一个节点

    if(pos==L->size)//在最后一个节点添加一个新节点
    {
        insertNode->next=NULL;
        temp->next=insertNode;
    }
    else//中间节点中插入
    {
        insertNode->next=temp->next;
        temp->next=insertNode;
    }
    L->size++;
}

list* generateRandomList(int n,int rangeL,int rangeR)//生成结点个数以及左右值
    {
        list* L=list_init();
        srand(time(NULL));
        for(int i=0;i<n;i++)
        {
            int randData=rand()%(rangeR-rangeL+1)+rangeL;
            listInsert(L,i,randData);
        }
        return L;
    }

void printList(list* L)
{
    node* testNode=L->head;
    for(int i=0;i<L->size;i++)
    {
        cout<<testNode->data<<"->";
        testNode=testNode->next;
    }
    cout<<"null"<<endl;
}



node* __mergeList(node* nd,int l,int mid,int r)
{
    int aux[r-l+1];
    node* temp=nd;
    for(int i=l;i<=r;i++)
    {
        aux[i-l]=temp->data;
        temp=temp->next;
    }
    int i=l,j=mid+1;
    for(int k=l;k<=r;k++)
    {
        if(i>mid)//左半部分放入完
        {
            nd->data=aux[j-l];
            nd=nd->next;
            j++;
        }
        else if(j>r)//右半部分放入完
        {
            nd->data=aux[i-l];
            nd=nd->next;
            i++;
        }
        else if(aux[i-l]<aux[j-l])
        {
            nd->data=aux[i-l];
            nd=nd->next;
            i++;
        }
        else
        {
            nd->data=aux[j-l];
            nd=nd->next;
            j++;
        }
    }
    return nd;
}


void mergeSortBUList(list* L)
{
    for(int sz=1;sz<=L->size;sz*=2)
    {
        node* temp=L->head;
        for(int i=0;i+sz<L->size;i+=sz+sz)//i+sz>n说明剩下一个分组不需要归并，此时若归并会发生越界
        {
            temp=__mergeList(temp,i,i+sz-1,min(i+sz+sz-1,L->size-1));
        }
    }
}

bool isSortedList(list* L)
{
    node* temp=L->head;
    for(int i=0;i<L->size-1;i++)
    {
        if(temp->data > temp->next->data)//前面的数比后面的数大则退出
            return false;
        temp=temp->next;
    }
    return true;
}

void testSortList(string sortName,void(*sort)(list*),list* L)
{
    clock_t startTime=clock();
    sort(L);
    clock_t endTime=clock();
    assert(isSortedList(L)&&"排序出错");
    cout<<sortName<<" : "<<double(endTime-startTime)/CLOCKS_PER_SEC<<"s"<<endl;
}


int main()
{
    int n=10000;
    list* L=generateRandomList(n,0,n);

    testSortList("margeSortList",mergeSortBUList,L);
    printList(L);
    return 0;
}