add a solution for 148

fishercoder1534 · fishercoder1534 · commit 403624425e99 · 2021-11-26T12:53:26.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_148.java b/src/main/java/com/fishercoder/solutions/_148.java
@@ -140,4 +140,56 @@ int getCount(ListNode head) {
             return cnt;
         }
     }
+
+    public static class Solution3 {
+        /**
+         * Credit: https://leetcode.com/problems/sort-list/solution/ top down approach.
+         */
+        public ListNode sortList(ListNode head) {
+            if (head == null || head.next == null) {
+                return head;
+            }
+            ListNode mid = getMid(head);
+            ListNode left = sortList(head);
+            ListNode right = sortList(mid);
+            return mergeList(left, right);
+        }
+
+        private ListNode mergeList(ListNode left, ListNode right) {
+            ListNode pre = new ListNode(-1);
+            ListNode tmp = pre;
+            while (left != null && right != null) {
+                if (left.val < right.val) {
+                    tmp.next = left;
+                    left = left.next;
+                } else {
+                    tmp.next = right;
+                    right = right.next;
+                }
+                tmp = tmp.next;
+            }
+            if (left != null) {
+                tmp.next = left;
+            } else if (right != null) {
+                tmp.next = right;
+            }
+            return pre.next;
+        }
+
+        private ListNode getMid(ListNode head) {
+            /**The key/trick is in this method:
+             * it directly uses this head to iterate, so that we could use this top down recursive approach.
+             * If we assign head to slow and fast pointers, then this algorithm will run into StackOverflow exception.
+             *
+             * This is an absolutely amazing method!*/
+            ListNode midPrev = null;
+            while (head != null && head.next != null) {
+                midPrev = (midPrev == null) ? head : midPrev.next;
+                head = head.next.next;
+            }
+            ListNode mid = midPrev.next;
+            midPrev.next = null;//this is the key, otherwise, StackOverflow exception will occur.
+            return mid;
+        }
+    }
 }
diff --git a/src/test/java/com/fishercoder/_148Test.java b/src/test/java/com/fishercoder/_148Test.java
@@ -0,0 +1,46 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.ListNode;
+import com.fishercoder.common.utils.LinkedListUtils;
+import com.fishercoder.solutions._148;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _148Test {
+    private static _148.Solution1 solution1;
+    private static _148.Solution2 solution2;
+    private static _148.Solution3 solution3;
+    private static ListNode head;
+    private static ListNode expected;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _148.Solution1();
+        solution2 = new _148.Solution2();
+        solution3 = new _148.Solution3();
+    }
+
+    @Test
+    public void test1() {
+        head = LinkedListUtils.contructLinkedList(new int[]{4, 2, 1, 3});
+        expected = LinkedListUtils.contructLinkedList(new int[]{1, 2, 3, 4});
+        assertEquals(expected, solution1.sortList(head));
+    }
+
+    @Test
+    public void test2() {
+        head = LinkedListUtils.contructLinkedList(new int[]{4, 2, 1, 3});
+        expected = LinkedListUtils.contructLinkedList(new int[]{1, 2, 3, 4});
+        assertEquals(expected, solution2.sortList(head));
+    }
+
+    @Test
+    public void test3() {
+        head = LinkedListUtils.contructLinkedList(new int[]{4, 2, 1, 3});
+        expected = LinkedListUtils.contructLinkedList(new int[]{1, 2, 3, 4});
+        assertEquals(expected, solution3.sortList(head));
+    }
+
+}
