单链表的归并排序

单链表的归并排序的归并排序的时间复杂度为O(nlog n),代码如下：

#include <iostream>
#include <list>
using namespace std;


//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==NULL || head->next==NULL) return head;
ListNode *p=head;
ListNode *q=head->next;
while(q!=NULL && q->next!=NULL)   
{
p=p->next; q=q->next->next;  //P每次往前进一个节点，q每次往前进两个节点，以便将链表分成两部分
}
q=p->next; p->next=NULL;    //把head分成两部分,q指向右半部分的头结点
return merge(sortList(head), sortList(q));  //合并两部分
}


ListNode *merge(ListNode *a, ListNode *b)    //合并a b 链表
{
ListNode *dummy=new ListNode(0);
ListNode *head=dummy, *c=head;
while((a!=NULL) && (b!=NULL))
{
if(a->val < b->val)
{
c->next=a; c=a; a=a->next;
}
else
{
c->next=b; c=b; b=b->next;
}
}
c->next = (a==NULL)? b : a;
return head -> next;
}
};


void main()
{
Solution s;
ListNode *head1 = new ListNode(2);
head1->next = new ListNode(4);
head1->next->next = new ListNode(6);
head1->next->next->next = new ListNode(3);
head1->next->next->next->next = new ListNode(5);


ListNode *head = s.sortList(head1);


while(head != 0)
{
cout << head->val;
head = head->next;
}
while(1);
}

如果难以理解，可以先看矢量是怎样实现的：

#include<iostream>
#include <vector>
using namespace std;


template<typename Comparable>
void mergeSort(vector<Comparable> &a)
{
vector<Comparable> tmpArray(a.size());
mergeSort(a,tmpArray,0,a.size()-1);
}


template<typename Comparable>
void mergeSort(vector<Comparable> &a,vector<Comparable> &tmpArray,int left,int right)
{
if (left<right)
{
int center = (left+right)/2;
mergeSort(a,tmpArray,left,center);
mergeSort(a,tmpArray,center+1,right);
merge(a,tmpArray,left,center+1,right);
}
}


template<typename Comparable>
void merge(vector<Comparable> &a,vector<Comparable> &tmpArray,int leftPos,int rightPos,int rightEnd)
{
int leftEnd = rightPos-1;
int tmpPos=leftPos;
int numElements = rightEnd-leftPos+1;
while (leftPos<=leftEnd && rightPos<=rightEnd)
{
if(a[leftPos]<=a[rightPos])
tmpArray[tmpPos++]=a[leftPos++];
else
tmpArray[tmpPos++]=a[rightPos++];
while(leftPos<=leftEnd)
tmpArray[tmpPos++]=a[leftPos++];
while(rightPos<=rightEnd)
tmpArray[tmpPos++]=a[rightPos++];
}
for (int i=0;i<numElements;i++,rightEnd--)
{
a[rightEnd] = tmpArray[rightEnd];
}
}


void main()
{
vector<int> array;
array.push_back(24);
array.push_back(13);
array.push_back(26);
array.push_back(1);
array.push_back(2);
array.push_back(27);
array.push_back(38);
array.push_back(15);
mergeSort(array);
for (int i = 0;i<8;i++)
{
cout<<array[i]<<endl;
}
while(1);
}