思路:
参考了力扣大神的思路,时间复杂度要求为O(nlogn),故采用归并排序,而递归进行归并排序的话要用到递归栈,空间复杂度不为O(1),故要采用非递归方法。
递归归并排序
ListNode *merge(ListNode *l1,ListNode * l2){
ListNode *p = new ListNode(0);
while(l1 != NULL && l2 != NULL){
if(l1->val < l2->val){
p->next = l1;
l1 = l1->next;
}
else{
p->next = l2;
l2 = l2->next;
}
p = p->next;
}
if(l1 != NULL)
p->next = l1;
if(l2 != NULL)
p->next = l2;
return p->next;
}
ListNode *sortList(ListNode *head) {
if(head == NULL || head->next == NULL)
return head;
ListNode *prev = NULL,*slow = head,*fast = head;
while(fast != NULL && fast->next != NULL){//分别针对奇数个结点和偶数个结点的情况
prev = slow;
slow = slow->next;
fast = fast->next->next;
}
prev->next = NULL;
ListNode *l1 = sortList(head);
ListNode *l2 = sortList(slow);
return merge(l1,l2);
}
非递归归并排序
class Solution {
public:
ListNode *cut(ListNode *head, int size){
ListNode *p = head;
while (--size && p)
p = p->next;
if (!p)
return NULL;
ListNode *next = p->next;
p->next = NULL;
return next;
}
ListNode *merge(ListNode *l1, ListNode *l2){
ListNode first(0);
ListNode *p = &first;
while (l1 && l2){
if (l1->val < l2->val){
p->next = l1;
l1 = l1->next;
}
else{
p->next = l2;
l2 = l2->next;
}
p = p->next;
}
p->next = l1 ? l1 : l2;
return first.next;
}
ListNode* sortList(ListNode* head) {
ListNode first(0);
first.next = head;
ListNode *p = head;
int length = 0;
while (p){
length++;
p = p->next;
}
for (int size = 1; size < length; size <<= 1){
ListNode *cur = first.next;
ListNode *t = &first;
while (cur){
ListNode *left = cur;
ListNode *right = cut(left, size);
cur = cut(right, size);
t->next = merge(left, right);
while (t->next)
t = t->next;
}
}
return first.next;
}
};