單鏈錶快速排序

21ca發表於2017-01-19
排序

點選(此處)摺疊或開啟

  1. public class LinkedListSortTest {
  2.     //bubble up
  3.     public static ListNode sortList(ListNode head) {
  4.         ListNode m = head;
  5.         ListNode tail = null;
  6.         while (m != tail && m.next != null) {
  7.             ListNode n = head;
  8.             while (n.next != null) {
  9.                 if (n.next.val < n.val) {
  10.                     swap(n, n.next);
  11.                 }
  12.                 n = n.next;
  13.             }
  14.             tail = n;
  15.             m = m.next;
  16.         }
  17.         return head;
  18.     }
  19.     
  20.     //quick sort
  21.     public static ListNode sortList2(ListNode head) {
  22.         ListNode next = head.next;
  23.         if (next == null) { // 1 element
  24.             return head;
  25.         } else if (next.next == null) { // 2 elements
  26.             if (head.val > next.val) {
  27.                 swap(head, next);
  28.             }
  29.             return head;
  30.         } else {
  31.             ListNode mid = getMidNode(head);
  32.             return merge(sortList(head), sortList(mid));
  33.         }
  34.     }


  37.     private static ListNode merge(ListNode m, ListNode n) {
  38. //        System.out.println("Merge " + m + " with " + n);
  39.         
  40.         ListNode head = new ListNode(0);
  41.         ListNode tail = head;
  42.         while (m != null && n != null) {
  43.             if (m.val < n.val) {
  44.                 tail.next = m;
  45.                 m = m.next;
  46.             } else {
  47.                 tail.next = n;
  48.                 n = n.next;
  49.             }
  50.             tail = tail.next;
  51.         }
  52.         if (m != null) {
  53.             tail.next = m;
  54.         }
  55.         if (n != null) {
  56.             tail.next = n;
  57.         }
  58. //        System.out.println("Merge result : " + head.next);
  59.         return head.next;
  60.     }

  62.     private static ListNode getMidNode(ListNode n) {
  63.         ListNode fast = n;
  64.         ListNode slow = n;
  65.         while (true){
  66.             if (fast.next != null) {
  67.                 fast = fast.next;
  68.                 if (fast.next != null) {
  69.                     fast = fast.next;
  70.                     slow = slow.next;
  71.                     continue;
  72.                 }
  73.             }
  74.             break;
  75.         }
  76.         ListNode mid = slow.next;
  77.         slow.next = null;
  78.         return mid;
  79.     }

  81.     private static void swap(ListNode n, ListNode m) {
  82.         int v = n.val;
  83.         n.val = m.val;
  84.         m.val = v;
  85.     }

  87.     public static void main(String[] args) {
  88.         ListNode head = new ListNode(0);
  89.         int i = 0;
  90.         ListNode n = head;
  91.         while (i++ < 20) {
  92.             n.next = new ListNode(i * 37 % 50);
  93. //            n.next = new ListNode(i);
  94.             n = n.next;
  95.         }

  97.         print(head);
  98.         print(sortList(head));
  99.         print(sortList2(head));

  101.     }

  103.     public static void print(ListNode n) {
  104.         while (n != null) {
  105.             System.out.print(n.val + " ");
  106.             n = n.next;
  107.         }
  108.         System.out.println();
  109.     }

  111. }

  113. class ListNode {
  114.     int val;
  115.     ListNode next;

  117.     ListNode(int x) {
  118.         val = x;
  119.     }
  120.     
  121.     public String toString() {
  122.         ListNode n = this;
  123.         StringBuilder sb = new StringBuilder("[");
  124.         while (n != null) {
  125.             sb.append(n.val + " ");
  126.             n = n.next;
  127.         }
  128.         sb.deleteCharAt(sb.length() - 1);
  129.         sb.append("]");
  130.         return sb.toString();
  131.     }
  132. }
來源於  https://leetcode.com/problems/sort-list/
148. Sort List 

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

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/10742815/viewspace-2132712/，如需轉載，請註明出處，否則將追究法律責任。

相關文章