LeetCode 148. 排序链表（Sort List）

题目描述

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

解题思路

本题其实是让用归并排序的思想对链表进行排序，分为两个阶段：首先将整个链表分为两部分，一般是从中间切开，对两部分分别进行排序；然后将两个排序好的链表合并成一个链表。下面分别对两步进行分析：

1. 将链表分为两部分时，要首先找到中间节点，考虑用快慢指针的方法，快指针每次走两步，慢指针每次走一步，这样当快指针无路可走即下两步出现空指针时，慢指针正好处于链表中间节点。然后从慢指针后把整个链表切成两半，两部分再分别进行递归排序
2. 将两个排序链表合并时，首先初始化一个伪头节点，用其next指针指向新链表的头节点。从两个排序链表的头节点开始比较，每次将值较小的节点拼接到新链表后，若遇到其中一个节点为空则将另一个链表拼接到新链表后，这样遍历到两个链表末尾，最后返回伪头节点的next指针

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode *quick = head, *slow = head;
        //快慢指针找到中间节点
        while(quick->next && quick->next->next){
            quick = quick->next->next;
            slow = slow->next;
        }
        quick = slow;
        slow = slow->next;
        quick->next = NULL;
        ListNode *first = sortList(head);
        ListNode *second = sortList(slow);
        return mergeList(first, second);
    }
    ListNode* mergeList(ListNode* first, ListNode* second){
        ListNode node(-1);
        ListNode *p = &node;
        while(first != NULL || second != NULL){
            int val1 = first == NULL ? INT_MAX : first->val;
            int val2 = second == NULL ? INT_MAX : second->val;
            if(val1 < val2){
                p->next = first;
                first = first->next;
            }
            else{
                p->next = second;
                second = second->next;
            }
            p = p->next;
        }
        return node.next;
    }
};