每日一题之排序链表

1. 题目描述

给定单向链表的头节点head，将其升序排列后并返回排序后的链表。

2. 暴力解法

将排序链表转化为排序数组，创建数组存储链表中的值，对数组进行升序排序，最后将数组中的值写到链表中。

typedef struct node
{
    int val;
    struct node *next;
}ListNode;

int cmp(const void *_a, const void *_b)
{
    int *a = (int *)_a;
    int *b = (int *)_b;
    return *a - *b;
}

ListNode *list_sort(ListNode *head)
{
    static int listVal[1024] = {0};
    int index = 0;
    ListNode *p = head;

    // save val to array
    while (p != NULL)
    {
        listVal[index++] = p->val;
        p = p->next;
    }

    // sort array
    qsort(listVal, index, sizeof(int), cmp);

    index = 0;
    p = head;
    // write val to list
    while (p != NULL)
    {
        p->val = listVal[index++];
        p = p->next;
    }

    return head;
}

3. 归并排序

typedef struct node
{
    int val;
    struct node *next;
}ListNode;

ListNode *merge(ListNode *head, ListNode *tail)
{
    ListNode tmp;
    tmp.val = 0;
    ListNode *p = &tmp;
    ListNode *l = head;
    ListNode *r = tail;
    while (l != NULL && r != NULL)
    {
        if (l->val <= r->val)
        {
            p->next = l;
            l = l->next;
        }
        else
        {
            p->next = r;
            r = r->next;
        }
        p = p->next;
    }

    if (l != NULL)
    {
        p->next = l;
    }
    else if (r != NULL)
    {
        p->next = r;
    }
    return tmp.next;
}

ListNode *merge_sort(ListNode *head, ListNode *tail)
{
    if (NULL == head)
    {
        return head;
    }

    if (head->next == tail)
    {
        head->next = NULL;
        return head;
    }

    ListNode *fast = head;
    ListNode *slow = head;
    while (fast != tail)
    {
        fast = fast->next;
        slow = slow->next;
        if (fast != tail)
        {
            fast = fast->next;
        }
    }
    ListNode *mid = slow;
    return merge(merge_sort(head, mid), merge_sort(mid, tail));
}

ListNode *list_sort(ListNode *head)
{
    return merge_sort(head, NULL);
}