[LeetCode] 148. Sort List 解题思路

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

问题：对一个单列表排序，要求时间复杂度为 O(n*logn)，额外空间为 O(1)。

O(n*logn) 时间排序算法，无法是 quick sort, merge sort, head sort。quick sort 需要灵活访问前后元素，适合于数组，merge sort 只需要从左到右扫过去即可，可用于列表结构。

当列表元素个数大于2时，将列表拆分为左右对半的两个子列表，对左右子列表分别排序，然后合并。

当列表元素个数小于等于2 时，直接对列表元素比较排序。

第一步中的合并操作，实际上另一个LeetCode题目 Merge Two Sorted Lists

需要注意的是，由于是单向列表，为了方便操作元素位置，每次比较操作比较的是指针的下一个元素，详情见 sortmerge 函数。

/**
* p 表示父节点
* ll, lr 分别表示左半列表的父节点，右半列表的父节点
*
*/
ListNode* sortmerge(ListNode* p, int len){

if (len <= 1) {
return p;
}

if (len == 2) {
if (p->next->val > p->next->next->val) {
int tmp = p->next->val;
p->next->val = p->next->next->val;
p->next->next->val = tmp;
}
return p;
}

int lenL = len / 2;
int lenR = len - lenL;

ListNode* ll = p;

ll = sortmerge(ll, lenL);

ListNode* lr = p;

for (int i = 0 ; i < lenL; i++) {
lr = lr->next;
}

lr = sortmerge(lr, lenR);

while (ll != lr && lenR > 0) {
if (ll->next->val <= lr->next->val) {
ll = ll->next;
}else{
ListNode* next2 = lr->next;
lr->next = lr->next->next;
next2->next = ll->next;
ll->next = next2;
lenR--;
}
}

return p;
}

ListNode* sortList(ListNode* head) {

ListNode* node = head;

int cnt = 0;
while (node != NULL) {
cnt++;
node = node->next;
}

ListNode* p = new ListNode(0);
p->next = head;

p = sortmerge(p, cnt);

head = p->next;

return head;
}

参考资料：

[LeetCode] Sort List, Solution, 水中的鱼