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;
}
};