Sort a linked list in O(n log n) time using constant space complexity.
对链表进行排序,要求时间复杂度为O(n log n),并且空间复杂度为常量。
运用归并排序的思想,每次将链表拆分成两个子链表,分别针对两个子链表进行排序,然后合并两个有序的子链表。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
//获取链表的中点,使用两个指针,快指针每次走两步,慢指针每次走一步,快指针到尾节点的时候慢指针对应为链表的中点
ListNode *getMiddle(ListNode *head) {
ListNode *slow = head;
ListNode *fast = head;
while (fast->next!=NULL && fast->next->next!=NULL) {
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
ListNode *sortList(ListNode *head) {
if (head==NULL || head->next==NULL)
return head;
ListNode *middle = getMiddle(head);
ListNode *next = middle->next;
middle->next = NULL;
return mergeLists(sortList(head), sortList(next));
}
//合并两个有序的子链表
ListNode *mergeLists(ListNode *a, ListNode *b) {
ListNode *prehead = new ListNode(-1);
ListNode *cur = prehead;
while (a!=NULL && b!=NULL) {
if (a->val <= b->val) {
cur->next = a;
a=a->next;
}
else {
cur->next = b;
b = b->next;
}
cur = cur->next;
}
if (a!=NULL)
cur->next = a;
else
cur->next = b;
cur = prehead->next;
delete prehead;
return cur;
}
};