Leetcode: Sort List - 归并

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

以前写过快排的，很复杂，也容易出错。用归并试试，发现相当简单，逻辑也很清楚。一次通过。

/**
 * 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 *fast = head;
        ListNode *slow = head;
        ListNode *tail = slow;
        while (fast != NULL && fast->next != NULL) {
            fast = fast->next->next;
            tail = slow;
            slow = slow->next;
        }
        
        tail->next = NULL;
        ListNode *first = sortList(head);
        ListNode *second = sortList(slow);
        
        // merge the 2 sorted lists
        head = new ListNode(0);
        tail = head;
        while (first != NULL && second != NULL) {
            if (first->val <= second->val) {
                tail->next = first;
                first = first->next;
            }
            else {
                tail->next = second;
                second = second->next;
            }
            tail = tail->next;
        }
        
        if (first != NULL) {
            tail->next = first;
        }
        else if (second != NULL) {
            tail->next = second;
        }
        
        tail = head->next;
        delete head;
        return tail;
    }
};

=======================第二次======================

/**
 * 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 *slow = head;
        ListNode *fast = head;
        ListNode *prev = NULL;
        while (fast != NULL && fast->next != NULL) {
            fast = fast->next->next;
            prev = slow;
            slow = slow->next;
        }
        prev->next = NULL;
        
        head = sortList(head);
        slow = sortList(slow);
        
        ListNode *new_head = new ListNode(0);
        ListNode *cur = new_head;
        while (head != NULL && slow != NULL) {
            if (head->val <= slow->val)  {
                cur->next = head;
                head = head->next;
            }
            else {
                cur->next = slow;
                slow = slow->next;
            }
            cur = cur->next;
        }
        
        if (head != NULL) {
            cur->next = head;
        }
        else if (slow != NULL) {
            cur->next = slow;
        }
        
        head = new_head->next;
        delete new_head;
        
        return head;
    }
};