排序链表
问题描述 :
在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。
示例 1:
输入: 4->2->1->3
输出: 1->2->3->4
示例 2:
输入: -1->5->3->4->0
输出: -1->0->3->4->5
输入说明 :
首先输入链表长度len,然后输入len个整数,以空格分隔。
输出说明 :
输出格式见范例
输入范例 :
5
-1 5 3 4 0
输出范例 :
head–>-1–>0–>3–>4–>5–>tail
#include<iostream>
using namespace std;
struct ListNode
{
int val;
ListNode *next;
ListNode() : val(0), next(NULL) {}
ListNode(int x) : val(x), next(NULL) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
class Solution {
// 归并排序链表
ListNode* mergeSort(ListNode* first, ListNode* last) {
if(first==last)
{
last->next=NULL;
return last;
}
ListNode *fast,*slow;
fast=first;
slow=first;
while(fast->next!=NULL &&fast->next->next!=NULL)//注意,这里的两个判断顺序不能错,否则可能会导致报错
{
fast=fast->next->next;
slow=slow->next;
}
ListNode*rightHead=mergeSort(slow->next,last);
slow->next=NULL;
ListNode* leftHead=mergeSort(first,slow);
return mergeList(leftHead, rightHead);
}
// 合并链表
ListNode* mergeList(ListNode* leftHead, ListNode* rightHead) {
ListNode *head2=new ListNode();
ListNode *p1=head2;
while(leftHead!=NULL &&rightHead!=NULL)
{
if(leftHead->val<=rightHead->val)
{
p1->next=leftHead;
leftHead=leftHead->next;
p1=p1->next;
}
else
{
p1->next=rightHead;
rightHead=rightHead->next;
p1=p1->next;
}
}
p1->next=(leftHead==NULL?rightHead:leftHead);
return head2->next;
}
public:
ListNode* sortList(ListNode* head) {
if(head==NULL) return head;
ListNode *last;
last=head;
while(last->next!=NULL)
{
last=last->next;
}
ListNode* newHead = mergeSort(head, last); // 对链表进行归并排序
return newHead;
}
};
ListNode *createByTail()
{
ListNode *head;
ListNode *p1,*p2;
int n=0,num;
int len;
cin>>len;
head=NULL;
while(n<len && cin>>num)
{
p1=new ListNode(num);
n=n+1;
if(n==1)
head=p1;
else
p2->next=p1;
p2=p1;
}
return head;
}
void displayLink(ListNode *head)
{
ListNode *p;
p=head;
cout<<"head-->";
while(p!= NULL)
{
cout<<p->val<<"-->";
p=p->next;
}
cout<<"tail\n";
}
int main()
{
ListNode* head = createByTail();
head=Solution().sortList(head);
displayLink(head);
return 0;
}
易错点: while(fast->next!=NULL &&fast->next->next!=NULL)的顺序容易忽略而可能导致报错。