题目地址：148. 排序链表

暴力解法

暴力思路很简单，获取链表所有的元素，然后排序，再构建新的链表。

public ListNode sortList(ListNode head) {
    
    List<Integer> list = new ArrayList<>();
    while (head!=null){
    
        list.add(head.val);
        head=head.next;
    }
    int[] array = list.stream().mapToInt(Integer::intValue).toArray();
    Arrays.sort(array);
    ListNode listNode = new ListNode();
    ListNode res = listNode;
    for (int i : array) {
    
        listNode.next = new ListNode(i);
        listNode = listNode.next;
    }
    return res.next;
}

进阶——归并排序

进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
要求 O(n log n）时间复杂度，有快速排序堆排序归并排序等，但是由于指针的不便利，这里毫无疑问使用归并更好。
在链表上使用归并有几个注意点

1. 设置统一头节点便于操作
2. 为保证常数空间，两两归并的时候使用切割链表：每次根据当前归并的步长，切割成当前需要的字符串，然后返回后面的头，这样既保证了空间，又保证了连续性。

public ListNode sortList(ListNode head) {
    
      ListNode dummyNode = new ListNode(0);
        //统一尾节点
        dummyNode.next = head;
        //每次两个 遍历
        int len =0;
        while(head!=null){
    
            head=head.next;
            len++;
        }
        ListNode work;
        ListNode tail;
        for (int step = 1; step < len; step<<=1) {
    
// 开始操作
            //左侧第一个节点
            work = dummyNode.next;
            //
            tail = dummyNode;
            while (work!=null){
    
                
                //tail用来拼接
                ListNode left = work;
                ListNode right = cut(left,step);
                //cut 后面的直接断掉不要了 left-step
                work = cut(right,step);
                //merge
                tail.next=merge(left,right);
                while (tail.next!=null){
    
                    tail=tail.next;
                }
            }
        }
        return dummyNode.next;
    }
    private ListNode cut(ListNode left, int step) {
    
        while (--step!=0 && left!=null  ){
    
            left=left.next;
        }
        //将当前的的与之后的切割，并将之后的返回
        if(left!=null){
    
            ListNode result = left.next;
            left.next = null;
            return result;
            //如果在规定步长内已经没有了，直接返回空值
        }else{
    
            return null;
        }
    }

    private static ListNode merge(ListNode list1, ListNode list2) {
    
        ListNode res = new ListNode(0);
        ListNode sorted = res;
        while (list1 !=null && list2!=null){
    
            if(list1.val<list2.val){
    
                res.next=list1;
                list1=list1.next;
            }else {
    
                res.next=list2;
                list2=list2.next;
            }
            res= res.next;
        }
        if(list1 == null){
    
            res.next=list2;
        }else {
    
            res.next = list1;
        }
        return sorted.next;
    }