58_leetcode_Sort List-优快云博客

本文介绍了一种在O(n log n)时间内使用常数空间复杂度对链表进行排序的方法，利用归并排序的思想实现链表节点的有序排列。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Sort a linked list in O(n log n) time using constant space complexity.

1:注意特殊情况；2:采用归并排序

    ListNode *sortList(ListNode *head)
    {
        if(head == NULL || head->next == NULL)
        {
            return head;
        }
        
        ListNode* slowNode = head;
        ListNode* fastNode = head->next;
        
        while(fastNode && fastNode->next)
        {
            slowNode = slowNode->next;
            fastNode = fastNode->next->next;
        }
        
        ListNode* firstNode = head;
        ListNode* secondNode = slowNode->next;
        slowNode->next = NULL;
        firstNode = sortList(firstNode);
        secondNode = sortList(secondNode);
        
        head = mergeTwoList(firstNode, secondNode);
        
        return head;
    }
    
    ListNode* mergeTwoList(ListNode* head1, ListNode* head2)
    {
        ListNode* newHead = NULL;
        ListNode *index = NULL;
        
        while(head1 && head2)
        {
            if(head1->val <= head2->val)
            {
                if(newHead == NULL)
                {
                    newHead = head1;
                    index = newHead;
                }
                else
                {
                    index->next = head1;
                    index = index->next;
                }
                head1 = head1->next;
            }
            else
            {
                if(newHead == NULL)
                {
                    newHead = head2;
                    index = newHead;
                }
                else
                {
                    index->next = head2;
                    index = index->next;
                }
                head2 = head2->next;
            }
        }
        
        index->next = (head1 == NULL ? head2 : head1);
        
        return newHead;
    }