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