refactor 725

fishercoder1534 · fishercoder1534 · commit 13cb0fdf1517 · 2021-09-29T09:14:03.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_725.java b/src/main/java/com/fishercoder/solutions/_725.java
@@ -7,18 +7,18 @@ public static class Solution1 {
         /**
          * My very original solution, but verbose.
          */
-        public ListNode[] splitListToParts(ListNode root, int k) {
-            int len = getLength(root);
+        public ListNode[] splitListToParts(ListNode head, int k) {
+            int len = getLength(head);
             int aveSize = len / k;
             int extra = len % k;
             ListNode[] result = new ListNode[k];
             for (int i = 0; i < k; i++) {
-                result[i] = root;
+                result[i] = head;
                 int aveSizeTmp = aveSize;
                 aveSizeTmp += extra-- > 0 ? 1 : 0;
                 int aveSizeTmp2 = aveSizeTmp;
                 while (aveSizeTmp-- > 0) {
-                    root = root.next;
+                    head = head.next;
                 }
                 if (result[i] != null) {
                     ListNode tmp = result[i];
@@ -46,17 +46,17 @@ public static class Solution2 {
         /**
          * More concise version
          */
-        public ListNode[] splitListToParts(ListNode root, int k) {
-            int len = getLength(root);
+        public ListNode[] splitListToParts(ListNode head, int k) {
+            int len = getLength(head);
             int aveSize = len / k;
             int extra = len % k;
             ListNode[] result = new ListNode[k];
             ListNode prev = null;
             for (int i = 0; i < k; i++, extra--) {
-                result[i] = root;
+                result[i] = head;
                 for (int j = 0; j < aveSize + (extra > 0 ? 1 : 0); j++) {
-                    prev = root;
-                    root = root.next;
+                    prev = head;
+                    head = head.next;
                 }
                 if (prev != null) {
                     prev.next = null;
@@ -75,4 +75,44 @@ private int getLength(ListNode root) {
             return len;
         }
     }
+
+    public static class Solution3 {
+        /**
+         * My original solution on 9/29/2021.
+         */
+        public ListNode[] splitListToParts(ListNode head, int k) {
+            ListNode[] ans = new ListNode[k];
+            int size = 0;
+            ListNode tmp = head;
+            while (tmp != null) {
+                tmp = tmp.next;
+                size++;
+            }
+            int minSize = size / k;
+            int remainder = size % k;
+            int i = 0;
+            if (head == null) {
+                while (i < k) {
+                    ans[i++] = null;
+                }
+            }
+            while (i < k) {
+                ListNode node = head;
+                tmp = node;
+                int len = minSize;
+                if (remainder > 0) {
+                    remainder--;
+                    len++;
+                }
+                while (len-- > 1) {
+                    tmp = tmp.next;
+                }
+                head = tmp.next;
+                tmp.next = null;
+                ans[i] = node;
+                i++;
+            }
+            return ans;
+        }
+    }
 }
diff --git a/src/test/java/com/fishercoder/_725Test.java b/src/test/java/com/fishercoder/_725Test.java
@@ -9,6 +9,7 @@
 public class _725Test {
     private static _725.Solution1 solution1;
     private static _725.Solution2 solution2;
+    private static _725.Solution3 solution3;
     private static ListNode root;
     private static int k;
     private static ListNode[] actual;
@@ -17,6 +18,7 @@ public class _725Test {
     public static void setup() {
         solution1 = new _725.Solution1();
         solution2 = new _725.Solution2();
+        solution3 = new _725.Solution3();
     }
 
     @Test
@@ -59,4 +61,24 @@ public void test4() {
         }
     }
 
+    @Test
+    public void test5() {
+        root = LinkedListUtils.contructLinkedList(new int[]{1, 2, 3});
+        k = 5;
+        actual = solution3.splitListToParts(root, k);
+        for (ListNode head : actual) {
+            LinkedListUtils.printList(head);
+        }
+    }
+
+    @Test
+    public void test6() {
+        root = LinkedListUtils.contructLinkedList(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+        k = 3;
+        actual = solution3.splitListToParts(root, k);
+        for (ListNode head : actual) {
+            LinkedListUtils.printList(head);
+        }
+    }
+
 }
