【Leetcode】148. Sort List

题目地址：

https://leetcode.com/problems/sort-list/

对一个链表排序。

法1：可以使用归并排序。虽然很好写，但这个不符合题目要求。代码如下：

public class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null) {
            return null;
        }
    
        return mergeSort(head);
    }
    
    private ListNode mergeSort(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        
        ListNode l1 = head;
        // 这里的mid取的是整个链表的中点，如果链表长为偶数则取的是靠前的中点
        ListNode mid = findMid(head);
        ListNode l2 = mid.next;
        // 要将链表从中间断开，才能继续归并排序
        mid.next = null;
    
        ListNode list1 = mergeSort(l1);
        ListNode list2 = mergeSort(l2);
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        while (list1 != null || list2 != null) {
            if (list1 == null) {
                cur.next = list2;
                break;
            }
            if (list2 == null) {
                cur.next = list1;
                break;
            }
            
            if (list1.val <= list2.val) {
                cur.next = list1;
                list1 = list1.next;
            } else {
                cur.next = list2;
                list2 = list2.next;
            }
            
            cur = cur.next;
        }
        return dummy.next;
    }
    
    private ListNode findMid(ListNode head) {
        if (head == null) {
            return null;
        }
        
        ListNode slow = head, fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
}

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        val = x;
    }
}

时间复杂度$O(n\log n)$，空间复杂度$O(\log n)$。

法2：接下来是不用递归的，时间复杂度$O(n\log n)$，空间复杂度$O(1)$的代码。其实也是归并排序，只不过不用递归，而是手动实现归并排序。代码如下：

public class Solution {
    public ListNode sortList(ListNode head) {
        // 先求一下链表的长度
        int n = 0;
        for (ListNode p = head; p != null; p = p.next) {
            n++;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
    	
    	// i模拟步长，两倍的增长，模拟自底向上的归并排序
        for (int i = 1; i < n; i *= 2) {
        	// cur是归并分块的第一个节点之前的那个节点
            ListNode cur = dummy;
            // j模拟归并排序的分块
            for (int j = 0; j + i < n; j += i * 2) {
                ListNode left = cur.next, right = cur.next;
                // 先将right挪到归并的第二个分块的头结点
                for (int k = 0; k < i; k++) {
                    right = right.next;
                }
                // 开始归并
                int l = 0, r = 0;
                while (l < i && r < i && right != null) {
                    if (left.val <= right.val) {
                        cur.next = left;
                        left = left.next;
                        l++;
                    } else {
                        cur.next = right;
                        right = right.next;
                        r++;
                    }
                    cur = cur.next;
                }
                // 归并剩余的值
                while (l < i) {
                    cur.next = left;
                    cur = cur.next;
                    left = left.next;
                    l++;
                }
                // 判断right != null是为了防止最后一个归并分块里的第二个区间长度不足
                while (r < i && right != null) {
                    cur.next = right;
                    cur = cur.next;
                    right = right.next;
                    r++;
                }
                cur.next = right;
            }
        }
        
        return dummy.next;
    }
}

时间复杂度$O(n\log n)$，空间$O(1)$。