LeetCode: Sort List 解题报告

Sort List

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

使用Merge Sort, 空间复杂度是 O(logN) 因为使用了栈空间。

SOLUTION 1:

使用Merge Sort来解决问题。

为什么不用QuickSort?
因为随机访问对于链表而言太耗时，而heap sort不可行。

注意，Find Mid用了2种解法。或者是让Fast提前结束，或是让Fast先走一步，目的就是要取得中间节点的前一个。这样做的目的，主要

是为了解决：

1->2->null

这一种情况。如果不这么做，slow会返回2.这样我们没办法切割2个Node的这种情况。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        // Nodes should be more than 2.
        if (head == null || head.next == null) {
            return head;
        }
        
        // get the mid node.
        ListNode midPre = getMidPre(head);
        
        // Cut the two list.
        ListNode right = midPre.next;
        midPre.next = null;
        
        // Sort the left side and the right side.
        ListNode left = sortList(head);
        right = sortList(right);
        
        // Merge the two sides together.
        return merge(left, right);
    }
    
    // get the pre node before mid.
    public ListNode getMidPre1(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        
        while (fast != null && fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        
        return slow;
    }
    
    // get the pre node before mid.
    public ListNode getMidPre(ListNode head) {
        ListNode slow = head;
        
        // fast提前一点儿。这样就可以得到前一个节点喽。
        ListNode fast = head.next;
        
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        
        return slow;
    }
    
    public ListNode merge(ListNode head1, ListNode head2) {
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        
        while (head1 != null && head2 != null) {
            if (head1.val < head2.val) {
                cur.next = head1;
                head1 = head1.next;
            } else {
                cur.next = head2;
                head2 = head2.next;
            }
            
            cur = cur.next;
        }
        
        if (head1 != null) {
            cur.next = head1;
        } else {
            cur.next = head2;
        }
        
        return dummy.next;
    }
}

SOLUTION 2:

使用快排也可以解决。但是注意，要加一个优化才可以过大数据，就是判断一下是不是整个链条是相同的节点，比如2 2 2 2 2 2 2 ，这样的就直接扫一次不用执行

快排，否则它会是N平方的复杂度。

参考资料：

https://oj.leetcode.com/discuss/3577/i-use-quick-sort-to-sort-the-list-but-why-i-get-time-limited

/*
    The Solution 2:
    Quick Sort.
    */
    public ListNode sortList(ListNode head) {
        if (head == null) {
            return null;
        }
        
        // Sort the list from 0 to len - 1
        return quickSort(head);
    }
    
    // The quick sort algorithm
    
    // All the elements are the same!
    public boolean isDuplicate(ListNode head) {
        while (head != null) {
            if (head.next != null && head.next.val != head.val) {
                return false;
            }            
            
            head = head.next;
        }
        
        return true;
    }
    
    public ListNode quickSort(ListNode head) {
        if (head == null) {
            return null;
        }
        
        // 如果整个链是重复的，直接跳过。
        if (isDuplicate(head)) {
            return head;
        }
        
        // Use the head node to be the pivot.
        ListNode headNew = partition(head, head.val);
        
        // Find the pre position of the pivoit.
        ListNode cur = headNew;
        
        ListNode dummy = new ListNode(0);
        dummy.next = headNew;
        
        ListNode pre = dummy;
        
        // Find the pre node and the position of the piviot.
        while (cur != null) {
            if (cur.val == head.val) {
                break;
            }
            
            // move forward.
            cur = cur.next;
            pre = pre.next;
        }
        
        // Cut the link to be three parts.
        pre.next = null;
        
        // Get the left link;
        ListNode left = dummy.next;
        
        // Get the right link.
        ListNode right = cur.next;
        cur.next = null;
        
        // Recurtion to call quick sort to sort left and right link.
        left = quickSort(left);
        right = quickSort(right);
        
        // Link the three part together.
        
        // Link the first part and the 2nd part.
        if (left != null) {
            dummy.next = left;
            
            // Find the tail of the left link.
            while (left.next != null) {
                left = left.next;
            }
            left.next = cur;
        } else {
            dummy.next = cur;
        }
        
        cur.next = right;
        
        // The new head;
        return dummy.next;
    }
    
    // Return the new head;
    public ListNode partition(ListNode head, int x) {
        if (head == null) {
            return null;
        }
        
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        
        ListNode pre = dummy;
        ListNode cur = head;
        
        // Record the big list.
        ListNode bigDummy = new ListNode(0);
        ListNode bigTail = bigDummy;
        
        while (cur != null) {
            if (cur.val >= x) {
                // Unlink the cur;
                pre.next = cur.next;
               
                // Add the cur to the tail of the new link.
                bigTail.next = cur;
                cur.next = null;
               
                // Refresh the bigTail.
                bigTail = cur;
               
                // 移除了一个元素的时候，pre不需要修改，因为cur已经移动到下一个位置了。
            } else {
                pre = pre.next;
            }
            
            cur = pre.next;
        }
        
        // Link the Big linklist to the smaller one.
        pre.next = bigDummy.next;
        
        return dummy.next;
    }

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/list/SortList.java