solution for Reverse Nodes in k-Group, O(N) runtime and memory, O(N) runtime and O(1) memory

Author: emikhalev

leetcode/reverse_nodes_in_k_group-solution-1.go

@@ -0,0 +1,66 @@
+// https://leetcode.com/problems/reverse-nodes-in-k-group/
+package main
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+
+func reverseKGroup(head *ListNode, k int) *ListNode {
+
+	first := head
+	var reversed, reversedLast *ListNode
+
+	for first != nil {
+
+		// [1,2,3,4,5], k=2; i=0..2 (0,1,2) last = &1, 0(last=&1), 1(last=&2), 2(last=&3),
+		last := first
+		for i := 0; i < k-1; i++ {
+			last = last.Next
+			if last == nil {
+				if reversed == nil {
+					reversed = first
+				} else {
+					reversedLast.Next = first
+				}
+				return reversed
+			}
+		}
+
+		// [1,2,3,4,5], [2,1], reversed = lst [2,1], reversedLast = lstLast [2, 1, ]
+		lst, lstLast := reverse(first, k) // returns reversed copy
+
+		if reversed == nil {
+			reversed = lst
+			reversedLast = lstLast
+		} else {
+			reversedLast.Next = lst
+			reversedLast = lstLast
+		}
+
+		first = last.Next // first = &3
+	}
+	return reversed
+}
+
+// reverse: [1, 2, 3, 4, 5], reversed = nil, current = &1, prev = &1
+func reverse(root *ListNode, k int) (reversed, reversedLast *ListNode) {
+	current := root
+	prev := reversed
+
+	for idx := 0; idx < k; idx++ {
+		elem := &ListNode{current.Val, nil}
+		elem.Next = prev       // 1
+		reversed = elem        // 2
+		prev = elem            // 3
+		current = current.Next // 4
+		if idx == 0 {
+			reversedLast = elem
+		}
+	}
+
+	return reversed, reversedLast
+}

leetcode/reverse_nodes_in_k_group-solution-2.go

@@ -0,0 +1,51 @@
+// https://leetcode.com/problems/reverse-nodes-in-k-group/
+package main
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+
+func reverseKGroup(head *ListNode, k int) *ListNode {
+	curr := head
+	firstReverse := true
+	var prev *ListNode = nil
+	for curr != nil {
+		last := curr // iter2: last = &3
+		for i := 0; i < k-1; i++ {
+			last = last.Next
+			if last == nil {
+				return head
+			}
+		}
+		nextCurr := last.Next
+
+		reverseInPlace(curr, k)
+		if prev != nil {
+			prev.Next = last
+		}
+
+		if firstReverse {
+			head = last
+			firstReverse = false
+		}
+		prev = curr
+		curr = nextCurr
+	}
+	return head
+}
+
+func reverseInPlace(root *ListNode, k int) {
+	curr := root
+	next := curr.Next
+	for i := 0; i < k-1; i++ {
+		tmp := next.Next
+		next.Next = curr
+		curr = next
+		next = tmp
+	}
+	root.Next = next
+}