排序演算法應該是最基礎的了，快速、歸併、選擇、堆排序等等

對於陣列而言可以隨機訪問，那麼對於連結串列呢，比如快排，兩個指標分別網後往前走，而沒有前驅指標的單向連結串列，無法完成這樣的操作，當然了可以採用快慢指標的方式，在提交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);
}