用归并法进行单链表排序

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* median(ListNode *head)
{
    if(head != nullptr && head->next != nullptr)
    {
        ListNode *m = head;
        ListNode *last = m->next;
        while(last->next != nullptr)
        {
            if((last = last->next) != nullptr) last = last->next;
            else break;
            m = m->next;
        }
        return m;
    }
    else return head;
}

ListNode* advance_aux(ListNode *head, int len)
{
    while(--len > 0) head = head->next;
    return head;
}

ListNode** merge_aux(ListNode **l_head, ListNode **r_head, int l_len, int r_len)
{
    cout<<"merge "
        <<(*l_head)->val<<' '<<l_len<<" and "
        <<(*r_head)->val<<' '<<r_len<<'
';
    ListNode **left = l_head, **right = r_head;
    while(l_len != 0 && r_len != 0)
    {
        while(r_len != 0 && (*right)->val < (*left)->val)
        {
            right = &(*right)->next;
            --r_len;
        }
        if(*right == *r_head)
        {
            while(l_len != 0 && (*left)->val <= (*right)->val)
            {
                left = &(*left)->next;
                --l_len;
            }
        }
        else
        {
            cout<<"	move ["
                <<(*r_head)->val<<","
                <<(r_len ? (*right)->val : -1)
                <<") before "
                <<(*left)->val<<"
";
            ListNode *tmp = *left;
            *left = *r_head;
            *r_head = *right;
            *right = tmp;
            left = &tmp->next;
            --l_len;
            right = r_head;
        }
    }
    while(r_len-- != 0)
    {
        ListNode *tmp = *left;
        *left = *r_head;
        *r_head = *right;
        *right = tmp;
    }
    return l_head;
}

ListNode** insertionSortList_aux(ListNode **head, int len)
{
    cout<<"deal "<<(*head)->val<<' '<<len<<'
';
    if(len > 2)
    {
        int left_len = len/2, right_len = len - left_len;
        head = insertionSortList_aux(head, left_len);
        ListNode *left_last = advance_aux(*head, left_len);
        ListNode **right_head = insertionSortList_aux(&left_last->next, right_len);
        head = merge_aux(head, right_head, left_len, right_len);
    }
    else if(len == 2)
    {
        if((*head)->val > (*head)->next->val)
        {
            int tmp = (*head)->val;
            (*head)->val = (*head)->next->val;
            (*head)->next->val = tmp;
        }
    }
    return head;
}

ListNode* insertionSortList(ListNode *head)
{
    int len = 0;
    ListNode *last = head;
    while(last != nullptr)
    {
        ++len;
        last = last->next;
    }
    insertionSortList_aux(&head, len);
    return head;
}

ListNode* insertNode(ListNode *head, int i)
{
    auto p = new ListNode{i};
    p->next = head;
    return p;
}

int main()
{
    ListNode *p = nullptr;
    p = insertNode(p, 0);
    p = insertNode(p, 0);
    p = insertNode(p, 0);
    p = insertNode(p, 0);
    for(ListNode *i = p; i != nullptr; i = i->next) cout<<i->val<<" ";
    cout<<endl;
    p = insertionSortList(p);
    for(ListNode *i = p; i != nullptr; i = i->next) cout<<i->val<<" ";
    cout<<endl;
    while(p != nullptr)
    {
        ListNode *tmp = p->next;
        delete p;
        p = tmp;
    }
}