LeetCode Sort a linked list 对一个链表排序

在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。

 

 

思路：先计算链表长度，以链表长度构造数组，将链表的节点的val存入数组，对数组进行排序（调用Arrays.sort()  时间复杂度为O(n log n)），再重新构造链表

java实现代码如下：

package linklist;

import java.util.Arrays;

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

public class linklist {
    public static ListNode sortList(ListNode head) {

        if( head == null ){
                return head;
            }
        int len =1;
        ListNode root = head;
        while(root.next != null) {                  //
            len++;
            root = root.next;
        }
        
        //System.out.println("len"+len);
        int[] a =new int[len];
        int i = 0;
        a[i] = head.val;
        while(head.next != null) {
            
            a[++i] = head.next.val;
            head = head.next;
        }
        Arrays.sort(a);
        
        
    return createLink(a);
            
    }
    
    
    public static ListNode createLink(int [] a) {
        int i=0;
        ListNode head1 = new ListNode(a[i]);
        ListNode h = head1;
        while(i<a.length-1) {
            h.next = new ListNode(a[++i]);
            h = h.next;
        }
        
        return head1;
    }
    

    public static void main(String[] args) {
        ListNode l = new ListNode(9);
        l.next = new ListNode(2);

        l.next.next = new ListNode(1);
        l.next.next.next = new ListNode(5);
        l.next.next.next.next = new ListNode(4);
        ListNode sortListNode = sortList(l);
        
        System.out.println(sortListNode.val);
        while(sortListNode.next !=null) {
            System.out.println(sortListNode.next.val);
            sortListNode = sortListNode.next;
            
        }

    }
}