给你链表的头结点 head ，请将其按升序排列并返回排序后的链表。如果能力允许，请保证 O(nlogn) 的时间复杂度和常数级空间复杂度


解题思路

可以借助归并排序的思想，这样就能保证时间复杂度为 O(nlogn)。如果使用递归来实现的话，则不能保证常数级空间复杂度，尽管链表的操作不需要额外的存储空间

通过递归实现链表归并排序，难点在于如何分割，具体步骤如下

  • 使用 fast slow 快慢双指针法，奇数个节点找到中点，偶数个节点找到中心左边的节点
  • 找到中点 slow 后，执行 slow.next = None 将链表切断
  • 继续递归分割，输入当前链表左端点 head 和中心节点 slow 的下一个节点 tmp
  • 当 head.next == None 时，说明只有一个节点了，直接返回此节点
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode slow = head, fast = head.next;
        while(fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode tmp = slow.next;
        slow.next = null;
        ListNode left = sortList(head);
        ListNode right = sortList(tmp);
        ListNode p = new ListNode(-1);
        ListNode pHead = p;
        while(left != null && right != null) {
            if(left.val < right.val) {
                p.next = left;
                left = left.next;
            } else {
                p.next = right;
                right = right.next;
            }
            p = p.next;
        }
        p.next = left == null ? right : left;
        return pHead.next;
    }
}