Added task 25.

Author: javadev

src/main/kotlin/g0001_0100/s0025_reverse_nodes_in_k_group/Solution.kt

@@ -0,0 +1,43 @@
+package g0001_0100.s0025_reverse_nodes_in_k_group
+
+// #Hard #Top_100_Liked_Questions #Linked_List #Recursion #Data_Structure_II_Day_13_Linked_List
+// #2022_04_26_Time_194_ms_(87.72%)_Space_35.7_MB_(100.00%)
+
+import com_github_leetcode.ListNode
+
+class Solution {
+    fun reverseKGroup(head: ListNode?, k: Int): ListNode? {
+        if (head?.next == null || k == 1) {
+            return head
+        }
+        var j = 0
+        var len = head
+        // loop for checking the length of the linklist, if the linklist is less than k, then return
+        // as it is.
+        while (j < k) {
+            if (len == null) {
+                return head
+            }
+            len = len.next
+            j++
+        }
+        // Reverse linked list logic applied here.
+        var c = head
+        var n: ListNode? = null
+        var prev: ListNode? = null
+        var i = 0
+        // Traverse the while loop for K times to reverse the node in K groups.
+        while (i != k) {
+            n = c!!.next
+            c.next = prev
+            prev = c
+            c = n
+            i++
+        }
+        // C1 is pointing to 1st node of K group, which is now going to point to the next K group
+        // linklist.
+        // recursion, for futher remaining linked list.
+        head.next = reverseKGroup(n, k)
+        return prev
+    }
+}

src/main/kotlin/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md

@@ -0,0 +1,46 @@
+25\. Reverse Nodes in k-Group
+
+Hard
+
+Given a linked list, reverse the nodes of a linked list _k_ at a time and return its modified list.
+
+_k_ is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of _k_ then left-out nodes, in the end, should remain as it is.
+
+You may not alter the values in the list's nodes, only nodes themselves may be changed.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg)
+
+**Input:** head = [1,2,3,4,5], k = 2
+
+**Output:** [2,1,4,3,5]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg)
+
+**Input:** head = [1,2,3,4,5], k = 3
+
+**Output:** [3,2,1,4,5]
+
+**Example 3:**
+
+**Input:** head = [1,2,3,4,5], k = 1
+
+**Output:** [1,2,3,4,5]
+
+**Example 4:**
+
+**Input:** head = [1], k = 1
+
+**Output:** [1]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `sz`.
+*   `1 <= sz <= 5000`
+*   `0 <= Node.val <= 1000`
+*   `1 <= k <= sz`
+
+**Follow-up:** Can you solve the problem in O(1) extra memory space?

src/test/kotlin/g0001_0100/s0025_reverse_nodes_in_k_group/SolutionTest.kt

@@ -0,0 +1,29 @@
+package g0001_0100.s0025_reverse_nodes_in_k_group
+
+import com_github_leetcode.ListNode
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun reverseKGroup() {
+        val head = ListNode()
+        val node1 = ListNode()
+        node1.`val` = 1
+        head.next = node1
+        val node2 = ListNode()
+        node2.`val` = 2
+        node1.next = node2
+        val node3 = ListNode()
+        node3.`val` = 3
+        node2.next = node3
+        val node4 = ListNode()
+        node4.`val` = 4
+        node3.next = node4
+        val node5 = ListNode()
+        node5.`val` = 5
+        node4.next = node5
+        assertThat(Solution().reverseKGroup(node1, 2).toString(), equalTo("2, 1, 4, 3, 5"))
+    }
+}