148 排序链表

题目描述：
在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 1:
输入: 4->2->1->3
输出: 1->2->3->4

示例 2:
输入: -1->5->3->4->0
输出: -1->0->3->4->5

方法1：
主要思路：
（1）直观的想，使用归并排序，从链表先以长度为1的子链表两两合并，形成长度为2的子链表集合，再将链表以长度为2的子链表，两两结合，形成长度为4的子链表集合……如此进行下去，直到最大的长度；
（2）为了实现这个过程，先定义了两个辅助函数，一个是merge函数，用于合并了两个有序链表，并将合并后的有序链表的头部返回，一个为 ListNode* cut(ListNode* head,int n) 函数，用于将链表分成两部分，前面一部分的长度为 n，返回的是后面一部分的头结点；
（3）以合并长度为 2 的子链表集合为例，先从链表的头部截取一个长度为 2 的子链表，再在返回的后半部分的头结点上截取一个长度为 2 的子链表，合并这两个有序的子链表，然后再找到这个合并的子链表的结尾结点，将其接到上面第二次截取子链表后的返回结点上，重复上述步骤，当长度为 2 的子链表合并结束后，接着就形成了长度为 4 的有序子链表集合，然后重复合并长度为 4的……；

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
	//将当前链表分为两部分，前面的为n个结点，返回值为后面部分的头结点指针
    ListNode* cut(ListNode* head,int n){
        while(head&&--n){
            head=head->next;
        }
        if(head==NULL)
            return NULL;
        ListNode* tmp=head->next;
        head->next=NULL;
        return tmp;
    }
	//合并两个有序的子链表
    ListNode* merge(ListNode* head1,ListNode* head2){
        ListNode* dummy=new ListNode(0);
        ListNode* tmp=dummy;
        while(head1&&head2){
            if(head1->val<head2->val){
                tmp->next=head1;
                tmp=head1;
                head1=head1->next;
            }
            else{
                tmp->next=head2;
                tmp=head2;
                head2=head2->next;
            }
        }
        tmp->next=head1==NULL?head2:head1;
        tmp=dummy->next;
        delete dummy;//释放内存
        return tmp;
    }

    ListNode* sortList(ListNode* head) {
        ListNode* dummy=new ListNode(0);
        dummy->next=head;
        ListNode* cur_head=head;
        int length=0;
        //先找到原链表的长度
        while(cur_head){
            ++length;
            cur_head=cur_head->next;
        }
        ListNode* cur_tail=NULL;
        //从长度为 1 的子链表开始合并，直到最后长度
        for(int i=1;i<length;i<<=1){
        	//每次的新的长度的子链表合并时，要从头开始
            cur_head=dummy->next;
            cur_tail=dummy;//合并部分的前一个结点，用于将合并后的链表重新连接到链表上
            while(cur_head){//直到合并的结尾
                ListNode* left=cur_head;//要合并的第一个链表的头结点
                ListNode* right=cut(cur_head,i);//要合并的第二个链表的头结点

                cur_head=cut(right,i);//下一组要合并的链表的头结点，或者说，没有合并的链表的头结点

                cur_tail->next=merge(left,right);//合并之前分割下来的两个子链表，并将合并后的链表，挂到之前已经合并好的链表的尾部

                while(cur_tail->next){//找到当前已经合并好的链表的尾部
                    cur_tail=cur_tail->next;
                }

            }
        }
        cur_head=dummy->next;
        delete dummy;//释放内存
        return cur_head;
    }
};