单向链表归并排序

#include <iostream>
using namespace std;

struct Node
{
    int value;
    Node *next;
};

Node* merge(Node *left, int leftLen, Node *right, int rightLen)
{
    if (NULL == left || NULL == right)
    {
        return NULL;
    }

    Node *head = NULL;
    if (left->value < right->value)
    {
        head = left;
        leftLen--;
        left = left->next;
    }
    else
    {
        head = right;
        rightLen--;
        right = right->next;
    }
    Node *p = head;

    while (leftLen && rightLen)
    {
        if (left->value < right->value)
        {
            p->next = left;
            p = p->next;
            left = left->next;
            leftLen--;
        }
        else
        {
            p->next = right;
            p = p->next;
            right = right->next;
            rightLen--;
        }
    }

    if (leftLen)
    {
        p->next = left;
    }
    else
    {
        p->next = right;
    }

    return head;
}


Node* mergeSort(Node *head, int len)
{
    if (len == 1)
    {
        head->next = NULL;
        return head;
    }

    Node *q = head;
    for (int i = 0; i < len/2; i++)
    {
        q = q->next;
    }

    Node *left = mergeSort(head, len/2);
    Node *right = mergeSort(q, len-len/2);
    return merge(left, len/2, right, len-len/2);
}