148. Sort List

Description

Sort a linked list in O(n log n) time using constant space complexity.

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4
Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5
Problem URL

Solution

给一个链表，要求在O（nlogn）时间内排序，并使用常数空间，相当于in-place。

We use the thought of merge sort to solve this problem

First, split the list into left and right two parts. Using slow, fast and prev pointers to realize it. prev = null set the list into two part.

Second, recursively call sortList() to left and right parts. So the list would be split to nodes.

Third, use mergeList() to merge the two list together.

In mergetList, we create a dummy head as the head of the new list. After that is the process of merget two sorted list. Use a cur pointer to add l1 or l2 nodes one by one. Then add rest nodes of l1 or l2.

Code

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        //1.split the list into two parts
        ListNode fast = head, slow = head, prev = null;
        while (fast != null && fast.next != null){
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = null;
        //2.sort left and right recursively
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);
        //3.merget the two list together
        return mergeList(l1, l2);
        
    }
    
    public ListNode mergeList(ListNode l1, ListNode l2){
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        while (l1 != null && l2 != null){
            if (l1.val < l2.val){
                cur.next = l1;
                l1 = l1.next;
            }
            else{
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        if (l1 == null){
            cur.next = l2;
        }
        if (l2 == null){
            cur.next = l1;
        }
        return dummy.next;
    }
}

Time Complexity: O(nlogn)
Space Complexity: O(1)

Review

Recursively version of mergeList

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        //1.split the list into two parts
        ListNode fast = head, slow = head, prev = null;
        while (fast != null && fast.next != null){
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = null;
        //2.sort left and right recursively
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);
        //3.merget the two list together
        return mergeList(l1, l2);
        
    }
    
    public ListNode mergeList(ListNode l1, ListNode l2){
        if (l1 == null){
            return l2;
        }
        if (l2 == null){
            return l1;
        }
        if (l1.val < l2.val){
            l1.next = mergeList(l1.next, l2);
            return l1;
        }
        else{
            l2.next = mergeList(l1, l2.next);
            return l2;
        }
    }
}