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

对于数组而言可以随机访问，那么对于链表呢，比如快排，两个指针分别网后往前走，而没有前驱指针的单向链表，无法完成这样的操作，当然了可以采用快慢指针的方式，在提交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);
}