leetcode之Sort List

原题如下：

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

leetcode上单纯的链表排序题有两个，这是其中一个，另一个是之前的插入排序/article/9500284.html，插入排序的查找需要从前往后寻找，其时间复杂度为O（n*n），这道题要求时间复杂度为O（nlogn），这一级别的排序有快排、堆排以及归并排序，由于快排在进行完一次快排后需要处理中间节点的连接问题，而堆排序需要寻找其子节点，相比较而言，归并排序是比较适合链表排序的。归并排序的思路是先分别排序，然后再将有序的合并，针对链表，需要首先查询链表长度，然后将链表二等分分别进行排序，然后将排序后的链表进行合并（即采用二路归并）。

class Solution {
public:
ListNode *sortList(ListNode *head) {
if(head == NULL || head->next == NULL)
return head;
int len = 0;
ListNode *p = head, *pre = head;
while(p != NULL)
{
len++;
p = p->next;
}
p = head;
for(int i = 1; i <= len / 2; i++){
pre = p;
p = p->next;
}
pre->next = NULL;
ListNode *head1 = sortList(head);
ListNode *head2 = sortList(p);
return merge(head1,head2);
}
ListNode *merge(ListNode *head1,ListNode *head2){
ListNode *head = new ListNode(0);
ListNode *p = head;
while(head1 != NULL && head2 != NULL){
if(head1->val <= head2->val){
p->next = head1;
head1 = head1->next;
}
else{
p->next = head2;
head2 = head2->next;
}
p = p->next;
p->next = NULL;
}
if(head1 != NULL)
p->next = head1;
else
p->next = head2;
head1 = head->next;
delete head;
return head1;
}
};

大牛总有过人之处，在求链表的中间节点时，可以采用快慢指针的方法，那样一次遍历链表即可找出中间节点，另外遍历后利用快慢指针断开链表的方法也很巧妙。

ListNode *merge(ListNode *head1,ListNode *head2){
ListNode *head = new ListNode(0);
ListNode *p = head;
while(head1 != NULL && head2 != NULL){
if(head1->val <= head2->val){
p->next = head1;
head1 = head1->next;
}
else{
p->next = head2;
head2 = head2->next;
}
p = p->next;
p->next = NULL;
}
if(head1 != NULL)
p->next = head1;
else
p->next = head2;
head1 = head->next;
delete head;
return head1;
}
ListNode *sortList(ListNode *head) {
if(head == NULL || head->next == NULL)
return head;
ListNode *fast = head, *low = head;
while(fast->next != NULL && fast->next->next != NULL){
fast = fast->next->next;
low = low->next;
}
fast = low;
low = low->next;
fast->next = NULL;
fast = sortList(head);
low = sortList(low);
return merge(fast,low);
}

两个代码中merge方法是相同的，不同的地方在于寻找链表中间节点（即将链表断开的位置）。