Reverse Nodes in k-Group

Author: volodimyr

25.reverse_node_in_k_group/reverse.go

@@ -0,0 +1,66 @@
+// 25. Reverse Nodes in k-Group
+// Topics: 'Linked List', 'Recursion'
+// Level: 'Hard'
+
+// Given the head of a linked list, reverse the nodes of the list k at a time, and return the 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:
+
+// Input: head = [1,2,3,4,5], k = 2
+// Output: [2,1,4,3,5]
+
+// Example 2:
+
+// Input: head = [1,2,3,4,5], k = 3
+// Output: [3,2,1,4,5]
+
+// Constraints:
+
+//     The number of nodes in the list is n.
+//     1 <= k <= n <= 5000
+//     0 <= Node.val <= 1000
+
+// Follow-up: Can you solve the problem in O(1) extra memory space?
+
+package reversenodeinkgroup
+
+type ListNode struct {
+	Next *ListNode
+	Val  int
+}
+
+func reverseKGroup(head *ListNode, k int) *ListNode {
+	dummy := &ListNode{}
+	cur := head
+	dcur := dummy
+	for cur != nil {
+		dcur.Next, dcur, cur = reverse(cur, k)
+	}
+	return dummy.Next
+}
+
+func reverse(head *ListNode, k int) (*ListNode, *ListNode, *ListNode) {
+	check := head
+	i := k
+	for check != nil && i > 1 {
+		check = check.Next
+		i--
+	}
+	if check == nil {
+		return head, nil, nil
+	}
+	var prev *ListNode
+	cur := head
+	for k > 0 && cur != nil {
+		next := cur.Next
+		cur.Next = prev
+		prev = cur
+		cur = next
+		k--
+	}
+	return prev, head, cur
+}

25.reverse_node_in_k_group/reverse_test.go

@@ -0,0 +1,59 @@
+package reversenodeinkgroup
+
+import (
+	"reflect"
+	"testing"
+)
+
+// Helper: convert slice to linked list
+func sliceToList(nums []int) *ListNode {
+	dummy := &ListNode{}
+	cur := dummy
+	for _, n := range nums {
+		cur.Next = &ListNode{Val: n}
+		cur = cur.Next
+	}
+	return dummy.Next
+}
+
+// Helper: convert linked list to slice
+func listToSlice(head *ListNode) []int {
+	var result []int
+	for head != nil {
+		result = append(result, head.Val)
+		head = head.Next
+	}
+	return result
+}
+
+func TestReverseKGroup(t *testing.T) {
+	tests := []struct {
+		input []int
+		k     int
+		want  []int
+	}{
+		// Full reversal
+		{[]int{1, 2, 3, 4, 5, 6}, 3, []int{3, 2, 1, 6, 5, 4}},
+		// Last group less than k
+		{[]int{1, 2, 3, 4, 5}, 3, []int{3, 2, 1, 4, 5}},
+		// k = 1, list unchanged
+		{[]int{1, 2, 3, 4}, 1, []int{1, 2, 3, 4}},
+		// k = list length, whole list reversed
+		{[]int{1, 2, 3, 4}, 4, []int{4, 3, 2, 1}},
+		// k > list length, list unchanged
+		{[]int{1, 2, 3}, 5, []int{1, 2, 3}},
+		// Single element
+		{[]int{1}, 2, []int{1}},
+	}
+
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			head := sliceToList(tt.input)
+			got := reverseKGroup(head, tt.k)
+			gotSlice := listToSlice(got)
+			if !reflect.DeepEqual(gotSlice, tt.want) {
+				t.Errorf("reverseKGroup(%v, %d) = %v; want %v", tt.input, tt.k, gotSlice, tt.want)
+			}
+		})
+	}
+}