leetcode----148.排序链表（自顶向下和自底向上两种归并排序）

148.排序链表（归并排序）

问题：给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

要求： O(n log n) 的时间复杂度和常数级空间复杂度

思路：

• 自顶向下归并排序

1. 归并排序需要将链表从中点一分为二，需要利用快慢指针找到链表中点。做法：快慢指针都指向当前链表的头节点，快指针每次走两步，慢指针每次走一步，当快指针走到链表尾部时，慢指针正好指向链表中点
2. 对两个链表进行排序
3. 将两个排序后的链表合并。第二三步其实对应的是归并排序里merge的过程。

上述过程可以通过递归实现。递归的终止条件是链表的节点个数小于或等于 1，即当链表为空或者链表只包含 1 个节点时，不需要对链表进行拆分和排序。

时间复杂度：O(nlogn)，其中 n 是链表的长度。

空间复杂度：O(logn)，其中 n 是链表的长度。空间复杂度主要取决于递归调用的栈空间。

class Solution {
    public ListNode sortList(ListNode head) {
       return sortList(head, null);
    }

    public ListNode sortList(ListNode head, ListNode tail){
        if (head == null) {
            return head;
        }
        if (head.next == tail) {
            head.next = null;
            return head;
        }
        ListNode slow = head, fast = head;
        while(fast != tail){
            slow = slow.next;
            fast = fast.next;
            if(fast != tail){
                fast = fast.next;
            }
        }
        ListNode mid = slow;
        ListNode left = sortList(head, mid);
        ListNode right = sortList(mid, tail);
        ListNode sorted = merge(left, right);
        return sorted;
    }

    public ListNode merge(ListNode head1, ListNode head2){
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead, temp1 = head1, temp2 = head2;
        while(temp1 != null && temp2 != null){
            if(temp1.val < temp2.val){
                temp.next = temp1;
                temp1 = temp1.next;
            } else {
                temp.next = temp2;
                temp2 = temp2.next;
            }
            temp = temp.next;
        }

        if(temp1 != null){
            temp.next = temp1;
        }

        if(temp2 != null){
            temp.next = temp2;
        }
        return dummyHead.next;
    }
}

• 自底向上归并排序

自底向上的归并排序，其实就是先将长度为length的链表拆成长度为subLength的子链表，然后再merge。其中subLength的长度为1，2，4，8…,最后一个子链表的长度可以小于subLength。

做法如下：来自官方题解

1. 用subLength 表示每次需要排序的子链表的长度，初始时subLength=1。

2. 每次将链表拆分成若干个长度为 subLength 的子链表（最后一个子链表的长度可以小于subLength），按照每两个子链表一组进行合并，合并后即可得到若干个长度为subLength×2的有序子链表（最后一个子链表的长度可以小于subLength×2）。

3. 将 subLength的值加倍，重复第 2步，对更长的有序子链表进行合并操作，直到有序子链表的长度大于或等于length，整个链表排序完毕。

当subLength=1时，合并后的链表应该是第1个到2个节点有序、第3个到4个节点有序…

当subLength=2时，合并后的链表应该是第1到4个节点有序、第5到8个节点有序…

…

当subLength < length(给定链表长度)且subLength * 2 >= length时，此时会将给定链表一分为二，左边子链表长度=subLength，右边子链表长度<=subLength且由前面的步骤可得，左右两个子链表都分别有序，则将这两个子链表merge，即排序并合并，所得即为将给定链表排序后的链表。

class Solution {
    public ListNode sortList(ListNode head) {
        if(head == null) return null;

        int length = 0;
        ListNode node = head;
        //获取给定链表长度
        while(node != null){
            length++;
            node = node.next;
        }
		
        //定义一个哑巴头节点，方便节点合并，并且可以记录合并后头节点位置
        ListNode dummyHead = new ListNode(0, head);
        for(int subLength = 1; subLength < length; subLength <<= 1){
            //因为是尾插法构造链表，所以prev节点相当于尾节点，方便构造新链表
            ListNode prev = dummyHead, curr = dummyHead.next;
            while(curr != null){
                ListNode head1 = curr;
                for(int i = 1; i < subLength && curr.next != null; i++){
                    curr = curr.next;
                }

                ListNode head2 = curr.next;
                //根据subLength拆分给定链表
                curr.next = null;
                curr = head2;
                //前面两两配对完之后，可能出现最后正好剩一个长度为subLength的子链表，
                //此时左子链表长度为subLength，右子链表长度为0，这里的curr != null 就是判断这种情况的。
                for(int i = 1; i < subLength && curr != null && curr.next != null; i++){
                    curr = curr.next;
                }
                //记录拆分后剩下子链表的头节点，方便下一个循环
                ListNode next = null;
                if(curr != null){
                    next = curr.next;
                    //根据subLength拆分给定链表
                    curr.next = null;
                }
                //排序并合并长度为subLength的两个子链表
                ListNode merged = merge(head1, head2);
                //将当前两个子链表排序并合并好的链表  与前面几次合并的子链表合并在一起
                prev.next = merged;
                //prev指向当前合并完成的子链表尾部
                while(prev.next != null){
                    prev = prev.next;
                }
                curr = next;
            }
        }
        return dummyHead.next;
    }

    public ListNode merge(ListNode head1, ListNode head2){
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead, temp1 = head1, temp2 = head2;
        while(temp1 != null && temp2 != null){
            if(temp1.val < temp2.val){
                temp.next = temp1;
                temp1 = temp1.next;
            } else {
                temp.next = temp2;
                temp2 = temp2.next;
            }
            temp = temp.next;
        }

        if(temp1 != null){
            temp.next = temp1;
        }

        if(temp2 != null){
            temp.next = temp2;
        }
        return dummyHead.next;
    }
}

整理思路，记录在博客，以便复习，若有误，望指正~