023 (3) add divide & conquer solution

stevencooks · stevencooks · commit cbbbced695f8 · 2015-09-30T22:03:18.000-04:00
diff --git a/src/_023_MergeKSortedLists/Solution.java b/src/_023_MergeKSortedLists/Solution.java
@@ -14,43 +14,44 @@
  */
 package _023_MergeKSortedLists;
 
-import java.util.Comparator;
-import java.util.PriorityQueue;
-import java.util.Queue;
-
 import com.leetcode.ListNode;
 
 /** see test {@link _023_MergeKSortedLists.SolutionTest } */
 public class Solution {
 
+    // divide and conquer, merge two lists at one time
     public ListNode mergeKLists(ListNode[] lists) {  
-        ListNode dummy = new ListNode(0);
-        ListNode node = dummy;
-        
-        Queue<ListNode> queue = new PriorityQueue<>(new Comparator<ListNode>() {
-            @Override
-            public int compare(ListNode o1, ListNode o2) {
-                return o1.val - o2.val;
-            }
-        });
-        
-        // push all heads into queue
-        for (ListNode head : lists) {
-            if (head != null) {
-                queue.add(head);        
-            }
+        return mergeKLists(lists, 0, lists.length - 1);
+    }
+
+    // divide and conquer
+    private ListNode mergeKLists(ListNode[] lists, int left, int right) {
+        if (left < right) {
+            int mid = left + (right - left) / 2;
+            return mergeTwo(mergeKLists(lists, left, mid), mergeKLists(lists, mid + 1, right));
+        } else if (left == right) {
+            return lists[left];
+        } else {
+            return null;
         }
-        
-        // choose next node from k candidates
-        while (!queue.isEmpty()) {
-            ListNode cur = queue.poll();
-            node.next = cur;
-            if (cur.next != null) {
-                queue.add(cur.next);
+    }
+
+    // merge two lists
+    private ListNode mergeTwo(ListNode list1, ListNode list2) {
+        ListNode dummy = new ListNode(0);
+        ListNode cur = dummy;
+        while (list1 != null && list2 != null) {
+            if (list1.val < list2.val) {
+                cur.next = list1;
+                list1 = list1.next;
+            } else {
+                cur.next = list2;
+                list2 = list2.next;
             }
-            node = node.next;
+            cur = cur.next;
         }
-        return dummy.next; 
+        cur.next = list1 != null ? list1 : list2;
+        return dummy.next;
     }
 
 }
diff --git a/src/_023_MergeKSortedLists/Solution2.java b/src/_023_MergeKSortedLists/Solution2.java
diff --git a/src/_023_MergeKSortedLists/SolutionHeap.java b/src/_023_MergeKSortedLists/SolutionHeap.java
@@ -0,0 +1,59 @@
+/**
+ * Time : O(NlgN) ; Space: O(N)
+ * @tag : Divide and Conquer; Linked List; Heap
+ * @by  : Steven Cooks
+ * @date: Sep 1, 2015
+ ***************************************************************************
+ * Description:
+ *
+ * Merge k sorted linked lists and return it as one sorted list. Analyze 
+ * and describe its complexity.
+ * 
+ ***************************************************************************
+ * {@link https://leetcode.com/problems/merge-k-sorted-lists/ }
+ */
+package _023_MergeKSortedLists;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+import com.leetcode.ListNode;
+
+/** see test {@link _023_MergeKSortedLists.SolutionHeapTest } */
+public class SolutionHeap {
+
+    // For next number, we want to find the smallest number from k lists' heads.
+    // The best data structure to know max/min from k elements is heap
+    public ListNode mergeKLists(ListNode[] lists) {  
+        ListNode dummy = new ListNode(0);
+        ListNode node = dummy;
+        
+        // stores head node of k merging lists
+        Queue<ListNode> queue = new PriorityQueue<>(new Comparator<ListNode>() {
+            @Override
+            public int compare(ListNode o1, ListNode o2) {
+                return o1.val - o2.val;
+            }
+        });
+        
+        // push all heads into queue
+        for (ListNode head : lists) {
+            if (head != null) {
+                queue.add(head);        
+            }
+        }
+        
+        // choose next node from k candidates
+        while (!queue.isEmpty()) {
+            ListNode cur = queue.poll();
+            node.next = cur;
+            if (cur.next != null) {
+                queue.add(cur.next);
+            }
+            node = node.next;
+        }
+        return dummy.next; 
+    }
+
+}
diff --git a/test/_023_MergeKSortedLists/SolutionHeapTest.java b/test/_023_MergeKSortedLists/SolutionHeapTest.java
@@ -12,17 +12,17 @@
 
 import com.leetcode.ListNode;
 
-public class Solution2Test {
+public class SolutionHeapTest {
     
-    /** Test method for {@link _023_MergeKSortedLists.Solution2 } */
-    Solution2 solution;
+    /** Test method for {@link _023_MergeKSortedLists.SolutionHeap } */
+    SolutionHeap solution;
 
     @Rule
     public Timeout globalTimeout = new Timeout(200);
 
     @Before
     public void setUp() throws Exception {
-        solution = new Solution2();
+        solution = new SolutionHeap();
     }
 
     @After
