在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。
示例 1:
输入: 4->2->1->3
输出: 1->2->3->4
示例 2:
输入: -1->5->3->4->0
输出: -1->0->3->4->5
这个题需要用到归并排序,归并排序有两个过程,一个是把序列分开,一个是把序列合并,这里需要用到两个函数,使用递归来进行编程,每一次递归都是分开序列和合并序列一起操作。对于归并排序不清楚的可以维基百科搜索一下,看一下代码,就会清楚很多。
C++源代码:
/**
* 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 || !head->next) return head;
ListNode *slow = head, *fast = head, *pre = head;
while(fast && fast->next){
pre = slow;
slow = slow->next;
fast = fast->next->next;
}
pre->next = NULL;
return merge(sortList(head), sortList(slow));
}
ListNode* merge(ListNode* left, ListNode* right){
ListNode *dummy = new ListNode(-1);
ListNode *cur = dummy;
while(left && right){
if(left->val < right->val){
cur->next = left;
left = left->next;
}
else{
cur->next = right;
right = right->next;
}
cur = cur->next;
}
if(left) cur->next = left;
if(right) cur->next = right;
return dummy->next;
}
};
python3源代码:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def sortList(self, head: ListNode) -> ListNode:
if head==None or head.next==None:
return head
slow = fast = pre = head
while fast and fast.next:
pre = slow
slow = slow.next
fast = fast.next.next
pre.next = None
return self.merge(self.sortList(head), self.sortList(slow))
def merge(self, left, right):
if left==None:
return right
if right==None:
return left
if left.val < right.val:
left.next = self.merge(left.next, right)
return left
else:
right.next = self.merge(left, right.next)
return right