leetcode148 排序链表(归并排序，两种实现方式)

尝试一：冒泡排序不好控制结束点，简单选择排序O(n^2) 操作简单，超时了。

正确解法：
这道题考虑时间复杂度更低的排序算法。题目的进阶问题要求达到 O(nlogn) 的时间复杂度和 O(1)的空间复杂度，时间复杂度是O(nlogn) 的排序算法包括归并排序、堆排序和快速排序（快速排序的最差时间复杂度是 O(n^2)，其中最适合链表的排序算法是归并排序。

归并排序基于分治算法。最容易想到的实现方式是自顶向下的递归实现，考虑到递归调用的栈空间，自顶向下归并排序的空间复杂度是O(logn)。如果要达到 O(1)的空间复杂度，则需要使用自底向上的实现方式。

//自顶而下的实现方式：时间复杂度：nlogn，空间复杂度跟递归层数有关
class Solution {
public:
    ListNode* Sort(ListNode* front, ListNode* end);
    ListNode* sort(ListNode* front1, ListNode* front2);
    ListNode* sortList(ListNode* head) {
        return Sort(head, NULL);
    }
};
ListNode* Solution::Sort(ListNode* front, ListNode* end){ 
    //返回值一定是指针，因为一个元素时得拆分！！！
    //分治算法，为了划分区间front end左开右闭
    
    if (front == NULL) return front;
    if (front->next == end) { //单个元素拆分开单个结点,next置为NULL！！！
        front->next = NULL;
        return front;
    } 
    ListNode* fast, *slow;
    fast = slow = front;
    //fast要移动到end的位置，而不是end前面的一位，注意下面这个循环的写法！！！
    while (fast != end){
        slow = slow->next;
        fast = fast->next;
        if(fast != end) fast = fast->next;
    }
    ListNode *mid = slow;
    //Sort函数当作参数，每次返回下一层形成的链表头指针！！！
    return sort(Sort(front, mid), Sort(mid, fast));  
}
ListNode* Solution::sort(ListNode* front1, ListNode* front2){
    //合并两个有序链表
    //两个链表都是以null结尾!!!
    //函数应该返回排序后的头指针，不应该为void！！！
    //做法：新建一个只具有一个结点的链表，不断改变指针指向形成大链表以后，返回head->next；即可!!!
    ListNode *head = new ListNode;
    ListNode *temp = head;
    while (front1 != NULL && front2 != NULL){
        if (front1->val <= front2->val) {
            temp->next = front1;
            front1 = front1->next;
        }else {
            temp->next = front2;
            front2 = front2->next;
        }
        temp = temp->next;
    }
    if (front1 != NULL) temp->next = front1;
    if (front2 != NULL) temp->next = front2;
    return head->next;
}

//自下向上的方式
/*当分组组数大于2时如何遍历完整个链表?zu1为第一个指针，zu2为第二个指针，next指向zu2后的结点，如果该结点不为NULL则继续分组（循环的条件）。处理完一组就将指针置为NULL，合并完后成一个链表！！！
*/
//在链表前面带一个结点来操作方便点，因为每次不知道该两组是不是第一次分出来的两组，新链表的头也就难以确定！！！
// <<1相当于乘以2，而不是 <<2！！！
class Solution {
public:
    ListNode* hebing(ListNode* front1, ListNode* front2); //合并两个有序链表
    ListNode* sortList(ListNode* head) {
        if (head == NULL) return head;
        int total_len = 0;
        ListNode *jishu = head;
        while (jishu){
            total_len++;
            jishu = jishu->next;
        }
        ListNode *list = new ListNode(0, head); //新链表，带头结点,next为head链表！！！
        for (int len = 1; len < total_len; len<<=1){ //每组中的个数,直到大于等于链表的长度！！！
            ListNode *start = list->next; //start为每组的头指针
            ListNode *listr = list; //指向新链表list末尾
            while (start){  //划分组，并对每组进行排序   
                ListNode *zu1 = start, *zu2 = NULL;
                for (int i = 1; i < len && start; i++){
                    start = start->next;
                }
                if (start == NULL ||  start->next == NULL){  //只有一组直接结束!!!
                    listr->next = zu1;
                    break;
                }
                ListNode *temp = start->next;
                start->next = NULL; //每组末尾都以NULL结尾
                start = temp;
                zu2 = start;
                for (int i = 1; i < len && start; i++){
                    start = start->next;
                }
                if (start == NULL){  //第二组个数不够时会越界到NULL，这里要加判断！！！
                    listr->next = hebing(zu1, zu2);
                    break;
                }
                temp = start->next;
                start->next = NULL;
                listr->next = hebing(zu1, zu2); //合并这两个分组链表
                while (listr->next != NULL){
                    listr = listr->next; //listr指向合并后的末尾
                }
                start = temp; //如果分完2组后start不为空继续进行循环分组
            }          
        }
        return list->next;
    }
};
ListNode* Solution::hebing(ListNode* front1, ListNode* front2){
    ListNode *head = new ListNode;
    ListNode *temp = head;
    while (front1 != NULL && front2 != NULL){
        if (front1->val <= front2->val) {
            temp->next = front1;
            front1 = front1->next;
        }else {
            temp->next = front2;
            front2 = front2->next;
        }
        temp = temp->next;
    }
    if (front1 != NULL) temp->next = front1;
    if (front2 != NULL) temp->next = front2;
    return head->next;
}