Update the solution of 92. Reverse Linked List II

Author: enginebai

leetcode/322.coin-change.md

@@ -145,6 +145,7 @@ fun coinChange(coins: IntArray, amount: Int): Int {
 
 private fun knapsack(coins: IntArray, amount: Int): Int {
     val dp = Array(coins.size + 1) { _ -> IntArray(amount + 1) }
+    // It's fine to exhange the order of the loops.
     for (i in 0..coins.size) {
         for (a in 0..amount) {
             dp[i][a] = if (a == 0) {

leetcode/92.reverse-linked-list-ii.md

@@ -2,67 +2,85 @@
 
 **Idea!** We find the part to reverse and the before / after node of reverse list, reuse modified `reverseLinkedList(node)` with length to reverse, and relink the before / after node pointer to correct.
 
+For example: 
+
 ```js
 1 -> 2 -> 3 -> 4 -> 5
 left = 2, right = 4
 
-// Traverse list to find the before / after pointer
-before = 1
-after = 5
+// Traverse list to find the node of before left, after right and last node of reversed list
+beforeLeft = 1
+afterRight = 5
+last = 2
 
 // Reverse from left to right
 reversedHead = reverseLinkedList(2 -> 3 -> 4), return 4
 
 // Relink before and after pointer to reverse list
-before -> reversedHead -> ... -> after
+beforeLeft -> reversedHead -> ... -> last -> afterRight
 ```
 
 ```kotlin
 fun reverseBetween(head: ListNode?, left: Int, right: Int): ListNode? {
-    // Pointers before and after reverse part
-    var before: ListNode? = null
-    var after: ListNode? = null
-    // Pointer to start reverse
-    var start: ListNode? = null
+    if (head == null) return null
 
-    // Traverse the list to locate the above pointers
-    var i = 1
-    var previous: ListNode? = null
+    // add sentinel
+    val sentinel = ListNode(0)
+    sentinel.next = head
+
+    // iterate to locate the left, before left, right, after right node.
+    var beforeLeft: ListNode? = null
+    var afterRight: ListNode? = null
+    // The last node after reversing
+    var last: ListNode? = null
+    var previous: ListNode? = sentinel
     var current: ListNode? = head
+    var i = 1
     while (current != null) {
         if (i == left) {
-            before = previous
-            start = current
+            beforeLeft = previous         
+            last = current       
         }
-        if (i == right + 1) {
-            after = current
+        if (i == right) {
+            afterRight = current.next
+            break
         }
-        i++
+
         previous = current
         current = current.next
+        i++
     }
 
-    // Reverse from left to right
-    var reversedHead = reverseLinkedList(start, right - left)
+    // reverse(left, right), return new head after reversed.
+    val newHead = reverse(last, current)
+    // val newHead = reverseLinkedList(start, right - left)
+    // val newHead = reverse(leftNode, right - left + 1)
 
-    // Relink the before pointer
-    before?.next = reversedHead
+    // relink before left node to new head.
+    beforeLeft?.next = newHead
+    
+    // relink the last node of revsered list to the node after right.
+    last?.next = afterRight
 
+    // return sentinel.next
+    return sentinel.next
+}
 
-    // Find the last node of reverse list
-    var lastNode: ListNode? = reversedHead
-    while (lastNode?.next != null) {
-        lastNode = lastNode.next
-    }
-    // Relink the after pointer
-    lastNode?.next = after
+private fun reverse(head: ListNode?, last: ListNode?): ListNode? {
+    var previous: ListNode? = null
+    var current: ListNode? = head
+    while (current != null && previous != last) {
+        val next = current.next
+        current.next = previous
 
-    // left == 1 means we reverse from start, the head will change.
-    return if (left == 1) reversedHead
-    else head
+        previous = current
+        current = next
+    }
+    return previous
 }
 
-private fun reverseLinkedList(node: ListNode?, length: Int): ListNode? {
+// Alternative implementation of reverse by length
+private fun reverse(node: ListNode?, length: Int): ListNode? {
     var i = 0
     var previous: ListNode? = null
     var current: ListNode? = node
@@ -76,43 +94,8 @@ private fun reverseLinkedList(node: ListNode?, length: Int): ListNode? {
     }
     return previous
 }
-```
-
-### More Concise
-For the example: `1 -> 2 -> 3 -> 4 -> 5`, left = 2, right = 4, we have to find `1 -> 2` and `4 -> 5`, and reverse between `2 -> 3 -> 4` and relink `1` to the new head of reversed list and relink the last node of reversed list to `5`.
-
-```kotlin
-fun reverseBetween(head: ListNode?, left: Int, right: Int): ListNode? {
-    // We introduce sentinel for help
-    val sentinel = ListNode(-1)
-    sentinel.next = head
-    
-    // Looking for 1 -> 2
-    var nodeBeforeLeft: ListNode? = sentinel
-    var leftNode: ListNode? = head
-    var i = 1
-    while (i < left) {
-        nodeBeforeLeft = leftNode
-        leftNode = leftNode?.next
-        i++
-    }
-    // Lookin for 4 -> 5
-    var rightNode: ListNode? = nodeBeforeLeft
-    var nodeAfterRight: ListNode? = rightNode?.next
-    while (i <= right) {
-        rightNode = rightNode?.next
-        nodeAfterRight = rightNode?.next
-        i++
-    }
-    
-    val reverseHead = reverse(leftNode, right - left + 1)
-    // Relink 1 -> reversed list
-    nodeBeforeLeft?.next = reverseHead
-    // Relink reversed list -> 5
-    leftNode?.next = nodeAfterRight
-    return sentinel.next
-}
 
+// Alternative implementation of reverse by counting
 private fun reverse(start: ListNode?, count: Int): ListNode? {
     var previous: ListNode? = null
     var current: ListNode? = start