归并排序
时间复杂度:O(nlog(n))
空间复杂度:由于使用了递归,O(log(n))
class Solution {
public:
ListNode* sortList(ListNode* head) {
if(head==nullptr){
return nullptr;
}else if(head->next==nullptr){
return head;
}
ListNode* fast=head;
ListNode* slow=head;
while(fast->next!=nullptr&&fast->next->next!=nullptr){
slow=slow->next;
fast=fast->next->next;
}
ListNode* pre=slow;
slow=slow->next; //右边链表起始
pre->next=nullptr; //左右两个链表截断
ListNode* l=sortList(head);
ListNode* r=sortList(slow);
return Merge(l,r);
}
private:
ListNode* Merge(ListNode* l, ListNode* r){
ListNode* res;
//初始化链表起始节点
if(l->val<r->val){
res=l;
l=l->next;
}else{
res=r;
r=r->next;
}
//合并链表
ListNode* tmp=res;
while(l!=nullptr&&r!=nullptr){
if(l->val<r->val){
tmp->next=l;
l=l->next;
}else{
tmp->next=r;
r=r->next;
}
tmp=tmp->next;
}
//确保两个列表剩余的连接
if(l!=nullptr){
tmp->next=l;
}else{
tmp->next=r;
}
return res;
}
};
快速排序
画图有助于理解链表的前进与交换问题
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
//交换函数
void swap(ListNode* p1, ListNode* p2) {
if (p1->val == p2->val) return;
p1->val ^= p2->val;
p2->val ^= p1->val;
p1->val ^= p2->val;
}
//快速排序
void quickSort(ListNode* left, ListNode* right) {
if(left == right || left==NULL || right == NULL) return;
int t= right->val; //作为对照点
ListNode* pre = NULL;
ListNode* cur = left; //cur维护当前比最右边大的链表
ListNode* p = left; //p作为扫查的指针
while(p!= right){
if(p->val < t)
{
swap(cur,p);
pre = cur;
cur = cur->next;
}
p = p->next; //更新
}
if(cur!=right){
swap(cur,right);
cur = cur->next;
}
quickSort(left,pre);
quickSort(cur,right);
}
ListNode* sortList(ListNode* head) {
ListNode* tail = head;
while (tail != NULL && tail->next != NULL) {
tail = tail->next;
}
quickSort(head, tail);
return head;
}
};