Update code

Author: zdong1995

README.md

@@ -25,9 +25,9 @@
 
 ### 1. 基础数据结构与算法 
 
-- [x] [半年零基础到 LeetCode 300 题，我的算法学习方法论](https://dongxiaoran.com/algo/basic/intro/)
-- [x] [当我们谈论刷题时，到底在刷什么](https://dongxiaoran.com/algo/basic/how/)
-- [x] [一题顶四题，一道题掌握 LinkedList 的 Iterative](https://dongxiaoran.com/algo/basic/iterativelist/): [Code](src/main/java/algorithm/basic/iterative)
+- [x] 半年零基础到 LeetCode 300 题，我的算法学习方法论: ✅ [Post](https://dongxiaoran.com/algo/basic/intro/)
+- [x] 当我们谈论刷题时，到底在刷什么: ✅ [Post](https://dongxiaoran.com/algo/basic/how/)
+- [x] 一题顶四题，一道题掌握 LinkedList 的 Iterative: ✅ [Post](https://dongxiaoran.com/algo/basic/iterativelist/) ⭐️ [Code](src/main/java/algorithm/basic/iterative)
 
 - [ ] Binary Search
 

src/main/java/algorithm/basic/iterative/FindMiddleOfList.java

@@ -1,4 +1,25 @@
 package algorithm.basic.iterative;
 
+import datastrcture.*;
+
+/**
+ * Given one linked list, find the middle node of the linked list.
+ * If there are even number of nodes, return the left middle one.
+ */
 public class FindMiddleOfList {
+    public ListNode findMiddle(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+
+        ListNode slow = head;
+        ListNode fast = head;
+        // odd number: slow stop at n+1, fast stop at 2n+1 -> fast.next = null
+        // even number: slow stop at n, fast stop at 1+2(n-1)=2n-1 -> fast.next.next = null
+        while (fast.next != null && fast.next.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return slow;
+    }
 }

src/main/java/algorithm/basic/iterative/MergeTwoSortedList.java

@@ -1,4 +1,32 @@
 package algorithm.basic.iterative;
 
+import datastrcture.*;
+
+/**
+ * Given two sorted lists, return the merged list of the given two lists.
+ */
 public class MergeTwoSortedList {
+    public ListNode mergeTwoList(ListNode one, ListNode two) {
+        // use dummy head to handle the corner case
+        ListNode dummy = new ListNode(0);
+        ListNode tail = dummy;
+
+        while (one != null || two != null) {
+            if (one.val < two.val) {
+                tail.next = one;
+                one = one.next;
+            } else {
+                tail.next = two;
+                two = two.next;
+            }
+            tail = tail.next;
+        }
+
+        if (one != null) {
+            tail.next = one;
+        } else {
+            tail.next = two;
+        }
+        return dummy.next;
+    }
 }

src/main/java/algorithm/basic/iterative/ReorderList.java

@@ -1,4 +1,67 @@
 package algorithm.basic.iterative;
 
+import datastrcture.*;
+
+/**
+ * Given a singly linked list L_0 → L_1 → … → L_{n-1} → L_n
+ * Reverse it to L_n → L_{n-1} → … → L_1 → L_0
+ */
 public class ReorderList {
+    public void reorderList(ListNode head) {
+        if (head == null || head.next == null) {
+            return;
+        }
+        ListNode mid = findMiddle(head);
+        ListNode secondHead = reverseList(mid.next);
+        mid.next = null; // de-link to avoid circle
+        head = mergeTwoList(head, secondHead);
+    }
+
+    private ListNode findMiddle(ListNode head) {
+        // assumption: head is not null
+        ListNode slow = head;
+        ListNode fast = head;
+        // odd number: slow stop at n+1, fast stop at 2n+1 -> fast.next = null
+        // even number: slow stop at n, fast stop at 1+2(n-1)=2n-1 -> fast.next.next = null
+        while (fast.next != null && fast.next.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return slow;
+    }
+
+    private ListNode reverseList(ListNode head) {
+        // assumption: head is not null
+        ListNode prev = null;
+        ListNode cur = head;
+        ListNode next = null;
+
+        while (cur != null) {
+            next = cur.next;
+            cur.next = prev;
+            prev = cur;
+            cur = next;
+        }
+        return prev;
+    }
+
+    private ListNode mergeTwoList(ListNode one, ListNode two) {
+        // use dummy head to handle the corner case, one is oddHead, two is evenHead
+        ListNode dummy = new ListNode(0);
+        ListNode tail = dummy;
+
+        while (one != null && two != null) {
+            tail.next = one;
+            one = one.next;
+            tail.next.next = two;
+            two = two.next;
+            tail = tail.next.next;
+        }
+
+        // first half sublist will be longer or equal than second half list
+        if (one != null) {
+            tail.next = one;
+        }
+        return dummy.next;
+    }
 }

src/main/java/algorithm/basic/iterative/ReverseLinkedList.java

@@ -1,4 +1,25 @@
 package algorithm.basic.iterative;
 
+import datastrcture.*;
+
+/**
+ * Given one single linked list, return the reversed list.
+ */
 public class ReverseLinkedList {
+    public ListNode reverseList(ListNode head) {
+        if (head == null) {
+            return null;
+        }
+        ListNode prev = null;
+        ListNode cur = head;
+        ListNode next = null;
+
+        while (cur != null) {
+            next = cur.next;
+            cur.next = prev;
+            prev = cur;
+            cur = next;
+        }
+        return prev;
+    }
 }

src/main/java/algorithm/pointers/merge/MergeKSortedList.java

@@ -1,125 +1,126 @@
 package algorithm.pointers.merge;
 
 import datastrcture.ListNode;
+
 import java.util.*;
 
 /**
  * You are given an array of k linked lists, each is sorted in ascending order.
  * Merge all the linked-lists into one sorted linked-list and return it.
  */
 public class MergeKSortedList {
-  // Method 1: K Pointers Merge with MinHeap
-  // Time: O(nK*logK), Space: O(K)
-  public ListNode mergeKSortedList(ListNode[] lists) {
-    if (lists == null || lists.length == 0) {
-      return null;
-    }
-
-    int k = lists.length;
-    // keep k pointers to merge k list, each time move next the list with smallest
-    // thus we can use a min heap with size k to compare the k pointers
-    PriorityQueue<ListNode> minHeap = new PriorityQueue<>(k, (n1, n2) -> n1.val - n2.val);
-    // initialize: add k head to the heap
-    for (ListNode head : lists) {
-      if (head != null) { // corner case: the k list may have null list
-        minHeap.offer(head);
-      }
+    // Method 1: K Pointers Merge with MinHeap
+    // Time: O(nK*logK), Space: O(K)
+    public ListNode mergeKSortedList(ListNode[] lists) {
+        if (lists == null || lists.length == 0) {
+            return null;
+        }
+
+        int k = lists.length;
+        // keep k pointers to merge k list, each time move next the list with smallest
+        // thus we can use a min heap with size k to compare the k pointers
+        PriorityQueue<ListNode> minHeap = new PriorityQueue<>(k, (n1, n2) -> n1.val - n2.val);
+        // initialize: add k head to the heap
+        for (ListNode head : lists) {
+            if (head != null) { // corner case: the k list may have null list
+                minHeap.offer(head);
+            }
+        }
+
+        ListNode dummy = new ListNode(0);
+        ListNode cur = dummy;
+
+        // each add the smallest node to the new list, and add next node into the heap
+        while (!minHeap.isEmpty()) {
+            ListNode node = minHeap.poll();
+            if (node.next != null) { // added all the nodes of one list
+                minHeap.offer(node.next);
+            }
+            cur.next = node;
+            node.next = null;
+            cur = node;
+        }
+
+        return dummy.next;
     }
 
-    ListNode dummy = new ListNode(0);
-    ListNode cur = dummy;
-
-    // each add the smallest node to the new list, and add next node into the heap
-    while (!minHeap.isEmpty()) {
-      ListNode node = minHeap.poll();
-      if (node.next != null) { // added all the nodes of one list
-        minHeap.offer(node.next);
-      }
-      cur.next = node;
-      node.next = null;
-      cur = node;
+    // Method 2: Recursive Binary Reduction, Divide and Conquer
+    // Time: O(nK*logK), Space: O(K) for call stack
+    public ListNode mergeKSortedList1(ListNode[] lists) {
+        if (lists == null || lists.length == 0) {
+            return null;
+        }
+        return merge(lists, 0, lists.length - 1);
     }
 
-    return dummy.next;
-  }
-
-  // Method 2: Recursive Binary Reduction, Divide and Conquer
-  // Time: O(nK*logK), Space: O(K) for call stack
-  public ListNode mergeKSortedList1(ListNode[] lists) {
-    if (lists == null || lists.length == 0) {
-      return null;
-    }
-    return merge(lists, 0, lists.length - 1);
-  }
-
-  // return merged lists that range from start to end
-  private ListNode merge(ListNode[] lists, int start, int end) {
-    // base case
-    if (start == end) { // the list itself
-      return lists[start];
+    // return merged lists that range from start to end
+    private ListNode merge(ListNode[] lists, int start, int end) {
+        // base case
+        if (start == end) { // the list itself
+            return lists[start];
+        }
+
+        int mid = start + (end - start) / 2;
+        ListNode left = merge(lists, start, mid);
+        ListNode right = merge(lists, mid + 1, end);
+        return mergeTwoList(left, right);
     }
 
-    int mid = start + (end - start) / 2;
-    ListNode left = merge(lists, start, mid);
-    ListNode right = merge(lists, mid + 1, end);
-    return mergeTwoList(left, right);
-  }
-
-  // Method 3: Iterative Binary Reduction
-  // Time: O(nK*logK), Space: O(1)
-  public ListNode mergeKSortedList2(ListNode[] lists) {
-    if (lists == null || lists.length == 0) {
-      return null;
+    // Method 3: Iterative Binary Reduction
+    // Time: O(nK*logK), Space: O(1)
+    public ListNode mergeKSortedList2(ListNode[] lists) {
+        if (lists == null || lists.length == 0) {
+            return null;
+        }
+
+        int k = lists.length;
+        // reuse the list node array
+        for (int interval = 1; interval < k; interval *= 2) {
+            for (int i = 0; i < (k - interval); i += interval * 2) {
+                lists[i] = mergeTwoList(lists[i], lists[i + interval]);
+            }
+        }
+        return lists[0];
     }
 
-    int k = lists.length;
-    // reuse the list node array
-    for (int interval = 1; interval < k; interval *= 2) {
-      for (int i = 0; i < (k - interval); i += interval * 2) {
-        lists[i] = mergeTwoList(lists[i], lists[i + interval]);
-      }
-    }
-    return lists[0];
-  }
-
-  // Method 4: Iterative Merge Two List
-  // Time: O(nK^2), Space: O(1)
-  public ListNode mergeKSortedList3(ListNode[] lists) {
-    if (lists == null || lists.length == 0) {
-      return null;
+    // Method 4: Iterative Merge Two List
+    // Time: O(nK^2), Space: O(1)
+    public ListNode mergeKSortedList3(ListNode[] lists) {
+        if (lists == null || lists.length == 0) {
+            return null;
+        }
+
+        ListNode merged = lists[0];
+        // for loop can cover the case that length == 1
+        // if length = 1, the for loop will be i = 1 < 1, will not enter
+        for (int i = 1; i < lists.length; i++) {
+            merged = mergeTwoList(lists[i], merged);
+        }
+
+        return merged;
     }
 
-    ListNode merged = lists[0];
-    // for loop can cover the case that length == 1
-    // if length = 1, the for loop will be i = 1 < 1, will not enter
-    for (int i = 1; i < lists.length; i++) {
-      merged = mergeTwoList(lists[i], merged);
-    }
-
-    return merged;
-  }
-
-  private ListNode mergeTwoList(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;
-    }
-    if (head2 != null) {
-      cur.next = head2;
+    private ListNode mergeTwoList(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;
+        }
+        if (head2 != null) {
+            cur.next = head2;
+        }
+        return dummy.next;
     }
-    return dummy.next;
-  }
 }