leetcode:sort-list

1.题目描述

Sort a linked list in O(n log n)
time using constant space complexity。

2.实现

（1）堆排序实现，它的时间复杂度为O(n log n)，但是由于堆排序的实现都是用数组，所以先将链表转化为数组，将数组的元素进行堆排序之后，再将元素转化为链表。

class Solution {
public:
int CountLength(ListNode *head)
{
int length=0;
while(head!=NULL)
{
++length;
head=head->next;
}
return length;
}
void swap(int &a,int &b)
{
int tmp=a;
a=b;
b=tmp;
}
void perDown(int A[],int i,int N)
{
int child;
int tmp;

for(tmp=A[i];2*i+1<N;i=child)
{
child=2*i+1;
if(child!=N-1&&A[child+1]>A[child])//保证只有一个左子树的时候就不计算它的右子树了
child++;
if(tmp<A[child])
A[i]=A[child];
else//若父节点比两个子节点或一个子节点大的话就不交换
break;
}
A[i]=tmp;
}
void HeapSort(int A[],int N)
{
int i;
for(i=(N-1)/2;i>=0;i--)
{
perDown(A,i,N);
}
for(i=N-1;i>0;i--)
{
swap(A[0],A[i]);
perDown(A,0,i);//将最大元素A[0]取出来与A[i]交换，然后将除了A[i]的前面的元素整理为最大堆
}
}
ListNode *sortList(ListNode *head) {
if(head==NULL||head->next==NULL)
return head;//注意边界条件
int length=CountLength(head);

int *list= (int *)malloc(sizeof(int)*length);
ListNode *p=head;
for(int i=0;i<length&&p!=NULL;i++)
{
list[i]=p->val;
p=p->next;
}
HeapSort(list,length);
p = head;
for(int i=0;i<length&&p!=NULL;i++){
p->val = list[i];
p = p->next;
}
return head;
}
};（2）归并排序实现，先用快慢指针法找到链表中间的节点，分别对前后两个部分进行归并排序。
class Solution {
public:
ListNode* MergeList(ListNode * list1, ListNode* list2)
{
if(list1 == NULL)
return list2;
if(list2 == NULL)
return list1;
ListNode * phead = NULL;
if(list1->val < list2->val)
{
phead = list1;
phead->next = MergeList(list1->next,list2);
}
else
{
phead = list2;
phead->next = MergeList(list2->next, list1);
}
return phead;
}

ListNode *sortList(ListNode *head) {
if(head == NULL || head->next == NULL) return head;
ListNode* slow = head;
ListNode* fast = head->next;
while(fast && fast->next)
{
fast = fast->next->next;
slow = slow->next;
}
ListNode * headb = slow->next;
slow->next = NULL;
return MergeList(sortList(head), sortList(headb));
}
};（3）快速排序实现
把第一个元素设置为privot，比枢纽元大的元素不动，比枢纽元小的元素进行头插到前面。

class Solution {
public:
ListNode* sortList(ListNode* head) {
return _sortList(head, nullptr);
}

private:
ListNode * _sortList(ListNode * start, ListNode * stop){
if(start==stop)
return start;
ListNode *privot=start;
ListNode *preOfcurr=start;
ListNode *curr=start->next;
while(curr!=stop)
{
if(curr->val>=privot->val)
{
preOfcurr=preOfcurr->next;
curr=curr->next;
}
else
{//先要删除该元素，再进行头插法
ListNode *p=new ListNode(curr->val);
preOfcurr->next=curr->next;
curr=curr->next;
p->next=start;
start=p;
}
}
ListNode *afterprivot=privot->next;
// privot->next=NULL;
ListNode *list1=_sortList(start,privot);
ListNode *list2=_sortList(afterprivot,stop);
privot->next=list2;

return list1;
}
};