Added solution for leet code 25

anxious-coder-lhs · anxious-coder-lhs · commit 4c02ca4885f4 · 2020-11-05T20:27:22.000+05:30
diff --git a/README.md b/README.md
@@ -61,6 +61,7 @@ Happy to accept any contributions to this in any langugage.
 2. [Read N Characters Given Read 4 II - Call Multiple Times - LeetCode 158](https://leetcode.com/problems/read-n-characters-given-read4-ii-call-multiple-times/) | [Solution 1](./level_hard/LeetCode_158_Hard.java) | [Solution 2 Optimized](./level_hard/LeetCode_158_Hard_1.java)
 3. [Leet Code 297 - Serialize Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/) | [Solution](./level_hard/SerializeDeserializeBinaryTree.ts)
 4. [Leet Code 428 - Serialize Deserialize N-Ary Tree](https://leetcode.com/problems/serialize-and-deserialize-n-ary-tree/) | [Solution](./level_hard/SerializeDeserializeNAryTree.ts)
+5. [Leet Code 25 - Reverse Linked List k Nodes at a time](https://leetcode.com/problems/reverse-nodes-in-k-group/) | [Solution](./level_hard/LeetCode%2025_Reverse%20Linked%20List%20K%20Nodes.ts)
 
 ## Sorting
 1. Bubble Sort | [Solution](./sorting/Sort_Bubble.js)
diff --git a/level_hard/LeetCode 25_Reverse Linked List K Nodes.ts b/level_hard/LeetCode 25_Reverse Linked List K Nodes.ts
@@ -0,0 +1,82 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+ /**
+  * Problem: Leet Code 25, Reverse Linked List K Nodes at a time.
+  * Solution: Uses an iterative approach to reverse linked list. Uses a modular function which can reverse the k nodes
+  * using an iterative approach. This approach uses last, curr and next pointer to keep on updating the pointers
+  * as we navigate. Additionally, it returns the new head, tail and next pointer in order to continue further. As it iterates,
+  * it just needs to modify the pointers along the way.
+  * 
+  * time: O(n) as all nodes need one traversal, O(1) space.
+  * 
+  * @param head 
+  * @param k 
+  */
+function reverseKGroup(head: ListNode | null, k: number): ListNode | null {
+    
+    if (head === null) return null;
+    
+    const length = getLength(head)
+    let next: ListNode | null = head, lastTail: ListNode | null = head;
+    for (let group = k; group <= length && next !== null; group += k) {
+        
+        // Reverse the subgroup, getting the group head and tail
+        const {groupHead, groupTail, groupNext} = reverseGroup(next, k);
+        
+        // Adjust the head pointer of previous group or main head.
+        if (group === k) head = groupHead;
+        else if (lastTail !== null) lastTail.next = groupHead;
+        
+        // Update the last tail to allow future updates.
+        lastTail = groupTail;
+        next = groupNext;
+    }
+    
+    // Point for pending items
+    if (lastTail !== null)
+        lastTail.next = next;
+    
+    return head;
+};
+
+function reverseGroup(head: ListNode | null, k: number): {
+    groupHead: ListNode | null,
+    groupTail: ListNode | null,
+    groupNext: ListNode | null
+} {
+    
+    let curr = head, last = null, next = null, count = 0;
+    while (count < k && curr !== null) {
+        next = curr.next
+        curr.next = last;
+        last = curr;
+        curr = next;
+        count++
+    }
+    
+    return {
+        groupHead: last,
+        groupTail: head,
+        groupNext: next
+    }
+}
+
+function getLength(head: ListNode | null) {
+    let curr = head, length = 0;
+    while(curr !== null) {
+        curr = curr.next;
+        length++;
+    }
+    
+    return length;
+}
