高效链表排序-归并算法

排序算法应该是最基础的了，快速、归并、选择、堆排序等等

对于数组而言可以随机访问，那么对于链表呢，比如快排，两个指针分别网后往前走，而没有前驱指针的单向链表，无法完成这样的操作，当然了可以采用快慢指针的方式，在提交leetcode的时候，发现快排是会超时的。

那么对于链表而言，可以采取一种怎么样的高效排序算法呢

归并排序

分而治之，分别拍好前后两个部分，然后合并两个有序链表，在合适不过，并且由于链表自带属性，合并链表还无需0(n)额外的空间，因此归并排序成为链表排序的首选。

我一直认为归并排序是挺好理解的，也比较简单，但是看了看网上的博客，为什么总感觉要么是放一堆代码，要么放一堆很长很长的代码，不如自己写个简单点的，完全按照数组的方式。

归并排序有几个子问题，链表分割，有序链表合并

链表分割

将一个链表分为为两个长度相等的链表（单数时会多一个）。

这个问题就相当于找到链表的中点，很简单的使用快慢指针，快指针走到尾节点，慢指针刚好走到一半。



第一个链表的头为head，第二个链表的头为慢指针的next指针。先拍后面，在拍前面。

此时需要注意，链表要分成两份，从中间断开，因此需要将慢节点的next指针设置为NULL很关键！！！。

ListNode* sort_list(ListNode *head)
{
if (head == NULL||head->next==NULL)//如果没有元素或者只有一个元素，那么就直接退出
return head;
ListNode *l = NULL,*r=NULL;
l = head;
r = head;
while (r->next && r->next->next)//找到中间节点
{
r = r->next->next;
l = l->next;
}
if (r == head)//如果此时只有两个节点，那么中间节点就是头节点，l=r=head，无限循环，因此特殊判断
{
r = r->next;
l->next = NULL;
return merge_list(r, l);
}
r=sort_list(l->next);//排序后半部分
l->next = NULL;//注意，一定要把前面从中间节点切断
l=sort_list(head);//排序前面一部分
ListNode* temp = merge_list(l, r);//合并两个有序链表
return temp;
}

有序链表合并

类似于合并有序数组，不过不需要额外的空间了。

比如 链表1 1->3->7->9

链表2 2->4->10->29

由于需要返回一个新的头部，而头部必然为链表1的头部或链表2的头部，因此不需要另外新建了。

代码如下

ListNode * merge_list(ListNode *head1, ListNode *head2)
{
ListNode *newhead = NULL ,*p=NULL;
if (head1 == NULL)
return head2;
if (head2 == NULL)
return head1;
if (head1->val <= head2->val)
{
newhead = head1;
head1 = head1->next;
}

else
{
newhead = head2;
head2 = head2->next;
}

p = newhead;
while (head1 != NULL && head2 != NULL)
{
if (head1->val <= head2->val)
{
p->next = head1;
head1 = head1->next;
p = p->next;
}
else
{
p->next = head2;
head2 = head2->next;
p = p->next;
}
}
while (head1 != NULL)
{
p->next = head1;
head1 = head1->next;
p = p->next;
}
while (head2 != NULL)
{
p->next = head2;
head2 = head2->next;
p = p->next;
}
p->next = NULL;
return newhead;
}

然后就是一个递归调用的过程

完整测试代码

struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
ListNode * merge_list(ListNode *head1, ListNode *head2)
{
ListNode *newhead = NULL ,*p=NULL;
if (head1 == NULL)
return head2;
if (head2 == NULL)
return head1;
if (head1->val <= head2->val)
{
newhead = head1;
head1 = head1->next;
}

else
{
newhead = head2;
head2 = head2->next;
}

p = newhead;
while (head1 != NULL && head2 != NULL)
{
if (head1->val <= head2->val)
{
p->next = head1;
head1 = head1->next;
p = p->next;
}
else
{
p->next = head2;
head2 = head2->next;
p = p->next;
}
}
while (head1 != NULL)
{
p->next = head1;
head1 = head1->next;
p = p->next;
}
while (head2 != NULL)
{
p->next = head2;
head2 = head2->next;
p = p->next;
}
p->next = NULL;
return newhead;
}ListNode* sort_list(ListNode *head)
{
if (head == NULL||head->next==NULL)//如果没有元素或者只有一个元素，那么就直接退出
return head;
ListNode *l = NULL,*r=NULL;
l = head;
r = head;
while (r->next && r->next->next)//找到中间节点
{
r = r->next->next;
l = l->next;
}
if (r == head)//如果此时只有两个节点，那么中间节点就是头节点，l=r=head，无限循环，因此特殊判断
{
r = r->next;
l->next = NULL;
return merge_list(r, l);
}
r=sort_list(l->next);//排序后半部分
l->next = NULL;//注意，一定要把前面从中间节点切断
l=sort_list(head);//排序前面一部分
ListNode* temp = merge_list(l, r);//合并两个有序链表
return temp;
}void printt_list(ListNode *head)
{
while (head)
{
cout << head->val << " ";
head = head->next;
}
}
void insert(ListNode *head,int val)
{
while (head->next)
{
head = head->next;
}
head->next = new ListNode(val);
}
};
int main()
{
Solution test;
ListNode * head = new ListNode(1);
test.insert(head, 42);
test.insert(head, 13);
test.insert(head, 6);
test.insert(head, 234);
test.insert(head, 19);
test.insert(head, 52);
test.insert(head, 41);
test.insert(head, 322);
test.insert(head, 234);
head=test.sort_list(head);
test.printt_list(head);
}