25. Reverse Nodes in k-Group

```Solution.c /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* reverseLinkedList(struct ListNode* head, int k) { struct ListNode* prev = NULL; struct ListNode* curr = head; while (k > 0) { struct ListNode* next = curr->next; curr->next = prev; prev = curr; curr = next; k--; } return prev; } struct ListNode* reverseKGroup(struct ListNode* head, int k) { struct ListNode* curr = head; int count = 0; while (curr != NULL && count < k) { curr = curr->next; count++; } if (count == k) { struct ListNode* reversedHead = reverseLinkedList(head, k); head->next = reverseKGroup(curr, k); return reversedHead; } return head; } ``` ```Solution.cpp /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *next) : val(x), next(next) {} * }; */ class Solution { public: ListNode* reverseKGroup(ListNode* head, int k) { ListNode* curr = head; int count = 0; while (curr != nullptr && count < k) { curr = curr->next; count++; } if (count == k) { ListNode* reversedHead = reverseLinkedList(head, k); head->next = reverseKGroup(curr, k); return reversedHead; } return head; } private: ListNode* reverseLinkedList(ListNode* head, int k) { ListNode* prev = nullptr; ListNode* curr = head; while (k--) { ListNode* next = curr->next; curr->next = prev; prev = curr; curr = next; } return prev; } }; ``` ```Solution.cs /** * Definition for singly-linked list. * public class ListNode { * public int val; * public ListNode next; * public ListNode(int val=0, ListNode next=null) { * this.val = val; * this.next = next; * } * } */ public class Solution { public ListNode ReverseKGroup(ListNode head, int k) { ListNode curr = head; int count = 0; while (curr != null && count < k) { curr = curr.next; count++; } if (count == k) { ListNode reversedHead = ReverseLinkedList(head, k); head.next = ReverseKGroup(curr, k); return reversedHead; } return head; } private ListNode ReverseLinkedList(ListNode head, int k) { ListNode prev = null; ListNode curr = head; while (k > 0) { ListNode next = curr.next; curr.next = prev; prev = curr; curr = next; k--; } return prev; } } ``` ```Solution.dart /** * Definition for singly-linked list. * class ListNode { * int val; * ListNode? next; * ListNode([this.val = 0, this.next]); * } */ class Solution { ListNode? reverseKGroup(ListNode? head, int k) { ListNode? curr = head; int count = 0; while (curr != null && count < k) { curr = curr.next; count++; } if (count == k) { final reversedHead = reverseLinkedList(head, k); head?.next = reverseKGroup(curr, k); return reversedHead; } return head; } ListNode? reverseLinkedList(ListNode? head, int k) { ListNode? prev = null; ListNode? curr = head; int remainingK = k; while (remainingK > 0 && curr != null) { final next = curr.next; curr.next = prev; prev = curr; curr = next; remainingK--; } return prev; } } ``` ```Solution.erl %% Definition for singly-linked list. %% %% -record(list_node, {val = 0 :: integer(), %% next = null :: 'null' | #list_node{}}). -spec reverse_k_group(Head :: #list_node{} | null, K :: integer()) -> #list_node{} | null. reverse_k_group(Head, K) when K =< 1 -> Head; reverse_k_group(Head, K) when Head =:= null -> null; reverse_k_group(Head, K) -> List = to_list(Head), NewList = reverse_k_chunks(List, K), from_list(NewList). to_list(null) -> []; to_list(#list_node{val = V, next = Next}) -> [V | to_list(Next)]. from_list([]) -> null; from_list([H | T]) -> #list_node{val = H, next = from_list(T)}. reverse_k_chunks(List, K) -> Groups = reverse_k_chunks(List, K, []), lists:append(Groups). reverse_k_chunks([], _K, Acc) -> lists:reverse(Acc); reverse_k_chunks(List, K, Acc) -> {Chunk, Rest, Len} = take_chunk(List, K, [], 0), Group = if Len == K -> Chunk; true -> lists:reverse(Chunk) end, reverse_k_chunks(Rest, K, [Group | Acc]). take_chunk(Rest, 0, Chunk, Len) -> {Chunk, Rest, Len}; take_chunk([], _K, Chunk, Len) -> {Chunk, [], Len}; take_chunk([H | T], K, Chunk, Len) -> take_chunk(T, K - 1, [H | Chunk], Len + 1). ``` ```Solution.ex # Definition for singly-linked list. # # defmodule ListNode do # @type t :: %__MODULE__{ # val: integer, # next: ListNode.t() | nil # } # defstruct val: 0, next: nil # end defmodule Solution do @SPEC reverse_k_group(head :: ListNode.t | nil, k :: integer) :: ListNode.t | nil def reverse_k_group(head, k) when k <= 1 or head == nil, do: head def reverse_k_group(head, k) do {nodes, rest, count} = take_nodes(head, k, [], 0) if count < k do head else rest_rev = reverse_k_group(rest, k) build_reversed(nodes, rest_rev) end end defp take_nodes(node, 0, acc, count), do: {Enum.reverse(acc), node, count} defp take_nodes(nil, _k, acc, count), do: {Enum.reverse(acc), nil, count} defp take_nodes(%ListNode{} = node, k, acc, count) do take_nodes(node.next, k - 1, [node | acc], count + 1) end defp build_reversed([], acc), do: acc defp build_reversed([%ListNode{val: v} | t], acc) do build_reversed(t, %ListNode{val: v, next: acc}) end end ``` ```Solution.go /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func reverseKGroup(head *ListNode, k int) *ListNode { curr := head count := 0 for curr != nil && count < k { curr = curr.Next count++ } if count == k { reversedHead := reverseLinkedList(head, k) head.Next = reverseKGroup(curr, k) return reversedHead } return head } func reverseLinkedList(head *ListNode, k int) *ListNode { var prev *ListNode = nil curr := head for k > 0 && curr != nil { next := curr.Next curr.Next = prev prev = curr curr = next k-- } return prev } ``` ```Solution.java /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * } */ class Solution { public ListNode reverseKGroup(ListNode head, int k) { ListNode curr = head; int count = 0; while (curr != null && count < k) { curr = curr.next; count++; } if (count == k) { ListNode reversedHead = reverseLinkedList(head, k); head.next = reverseKGroup(curr, k); return reversedHead; } return head; } private ListNode reverseLinkedList(ListNode head, int k) { ListNode prev = null; ListNode curr = head; while (k > 0) { ListNode next = curr.next; curr.next = prev; prev = curr; curr = next; k--; } return prev; } } ``` ```Solution.js /** * Definition for singly-linked list. * function ListNode(val, next) { * this.val = (val===undefined ? 0 : val) * this.next = (next===undefined ? null : next) * } */ /** * @param {ListNode} head * @param {number} k * @return {ListNode} */ var reverseKGroup = function(head, k) { let curr = head; let count = 0; while (curr !== null && count < k) { curr = curr.next; count++; } if (count === k) { const reversedHead = reverseLinkedList(head, k); head.next = reverseKGroup(curr, k); return reversedHead; } return head; }; /** * Reverses a linked list of size k and returns the new head. * @param {ListNode} head * @param {number} k * @return {ListNode} */ function reverseLinkedList(head, k) { let prev = null; let curr = head; while (k > 0) { const next = curr.next; curr.next = prev; prev = curr; curr = next; k--; } return prev; } ``` ```Solution.kt /** * Example: * var li = ListNode(5) * var v = li.`val` * Definition for singly-linked list. * class ListNode(var `val`: Int) { * var next: ListNode? = null * } */ class Solution { fun reverseKGroup(head: ListNode?, k: Int): ListNode? { var curr = head var count = 0 while (curr != null && count < k) { curr = curr.next count++ } if (count == k) { val reversedHead = reverseLinkedList(head, k) // Recursively process the remaining list head?.next = reverseKGroup(curr, k) return reversedHead } return head } private fun reverseLinkedList(head: ListNode?, k: Int): ListNode? { var prev: ListNode? = null var curr = head var remainingK = k while (remainingK > 0 && curr != null) { val next = curr.next curr.next = prev prev = curr curr = next remainingK-- } return prev } } ``` ```Solution.php /** * Definition for a singly-linked list. * class ListNode { * public $val = 0; * public $next = null; * function __construct($val = 0, $next = null) { * $this->val = $val; * $this->next = $next; * } * } */ class Solution { /** * @param ListNode $head * @param Integer $k * @return ListNode */ function reverseKGroup($head, $k) { $curr = $head; $count = 0; while ($curr !== null && $count < $k) { $curr = $curr->next; $count++; } if ($count === $k) { $reversedHead = $this->reverseLinkedList($head, $k); // Recursively process the remaining list $head->next = $this->reverseKGroup($curr, $k); return $reversedHead; } return $head; } /** * Reverses a linked list of size k and returns the new head. * @param ListNode $head * @param Integer $k * @return ListNode */ private function reverseLinkedList($head, $k) { $prev = null; $curr = $head; while ($k > 0) { $next = $curr->next; $curr->next = $prev; $prev = $curr; $curr = $next; $k--; } return $prev; } } ``` ```Solution.py # Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solution: def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]: curr = head count = 0 while curr and count < k: curr = curr.next count += 1 if count == k: reversed_head = self.reverseLinkedList(head, k) head.next = self.reverseKGroup(curr, k) return reversed_head return head def reverseLinkedList(self, head: Optional[ListNode], k: int) -> Optional[ListNode]: prev = None curr = head while k > 0: next_node = curr.next curr.next = prev prev = curr curr = next_node k -= 1 return prev ``` ```Solution.rb # Definition for singly-linked list. # class ListNode # attr_accessor :val, :next # def initialize(val = 0, _next = nil) # @Val = val # @next = _next # end # end # @param {ListNode} head # @param {Integer} k # @return {ListNode} def reverse_k_group(head, k) curr = head count = 0 while curr != nil && count < k curr = curr.next count += 1 end if count == k reversed_head = reverse_linked_list(head, k) head.next = reverse_k_group(curr, k) return reversed_head end head end def reverse_linked_list(head, k) prev = nil curr = head while k > 0 && curr != nil next_node = curr.next curr.next = prev prev = curr curr = next_node k -= 1 end prev end ``` ```Solution.rkt ; Definition for singly-linked list: #| ; val : integer? ; next : (or/c list-node? #f) (struct list-node (val next) #:mutable #:transparent) ; constructor (define (make-list-node [val 0]) (list-node val #f)) |# (define (reverse-k-group head k) (define (has-k? node k) (let loop ([n node] [i 0]) (cond [(= i k) #t] [(not n) #f] [else (loop (list-node-next n) (add1 i))]))) (define (reverse-first-k node k) (let loop ([curr node] [prev #f] [i 0]) (if (= i k) (values prev curr) (let ([next (list-node-next curr)]) (set-list-node-next! curr prev) (loop next curr (add1 i)))))) (define (process curr new-head last-tail) (if (not curr) new-head (if (has-k? curr k) (let-values ([(rev-head rest) (reverse-first-k curr k)]) (when last-tail (set-list-node-next! last-tail rev-head)) (process rest (or new-head rev-head) curr)) (begin (when last-tail (set-list-node-next! last-tail curr)) (if new-head new-head curr))))) (process head #f #f)) ``` ```Solution.rs // Definition for singly-linked list. // #[derive(PartialEq, Eq, Clone, Debug)] // pub struct ListNode { // pub val: i32, // pub next: Option<Box<ListNode>> // } // impl ListNode { // #[inline] // fn new(val: i32) -> Self { // ListNode { // next: None, // val // } // } // } impl Solution { pub fn reverse_k_group(head: Option<Box<ListNode>>, k: i32) -> Option<Box<ListNode>> { let k_usize = k as usize; let mut count = 0; let mut ptr = &head; while let Some(node) = ptr { count += 1; if count == k_usize { break; } ptr = &node.next; } if count < k_usize { return head; } let (mut reversed_head, remainder) = Self::reverse_linked_list(head, k_usize); if let Some(ref mut node) = reversed_head { let mut tail = node.as_mut(); while let Some(ref mut next_node) = tail.next { tail = next_node.as_mut(); } tail.next = Self::reverse_k_group(remainder, k); } reversed_head } fn reverse_linked_list(mut head: Option<Box<ListNode>>, k: usize) -> (Option<Box<ListNode>>, Option<Box<ListNode>>) { let mut prev: Option<Box<ListNode>> = None; let mut curr = head.take(); let mut remaining_k = k; while remaining_k > 0 { if let Some(mut node) = curr { let next = node.next.take(); node.next = prev; prev = Some(node); curr = next; remaining_k -= 1; } else { break; } } (prev, curr) } } ``` ```Solution.scala /** * Definition for singly-linked list. * class ListNode(_x: Int = 0, _next: ListNode = null) { * var next: ListNode = _next * var x: Int = _x * } */ object Solution { def reverseKGroup(head: ListNode, k: Int): ListNode = { var curr: ListNode = head var count: Int = 0 while (curr != null && count < k) { curr = curr.next count += 1 } if (count == k) { val reversedHead: ListNode = reverseLinkedList(head, k) // Recursively process the remaining list head.next = reverseKGroup(curr, k) return reversedHead } head } def reverseLinkedList(head: ListNode, k: Int): ListNode = { var prev: ListNode = null var curr: ListNode = head var remainingK: Int = k while (remainingK > 0 && curr != null) { val next: ListNode = curr.next curr.next = prev prev = curr curr = next remainingK -= 1 } prev } } ``` ```Solution.swift /** * Definition for singly-linked list. * public class ListNode { * public var val: Int * public var next: ListNode? * public init() { self.val = 0; self.next = nil; } * public init(_ val: Int) { self.val = val; self.next = nil; } * public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; } * } */ class Solution { func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? { var curr = head var count = 0 while curr != nil && count < k { curr = curr?.next count += 1 } if count == k { let reversedHead = reverseLinkedList(head, k) head?.next = reverseKGroup(curr, k) return reversedHead } return head } private func reverseLinkedList(_ head: ListNode?, _ k: Int) -> ListNode? { var prev: ListNode? = nil var curr = head var remainingK = k while remainingK > 0 && curr != nil { let next = curr?.next curr?.next = prev prev = curr curr = next remainingK -= 1 } return prev } } ``` ```Solution.ts /** * 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) * } * } */ function reverseKGroup(head: ListNode | null, k: number): ListNode | null { let curr: ListNode | null = head; let count: number = 0; while (curr !== null && count < k) { curr = curr.next; count++; } if (count === k) { const reversedHead: ListNode | null = reverseLinkedList(head, k); if (head !== null) { head.next = reverseKGroup(curr, k); } return reversedHead; } return head; } function reverseLinkedList(head: ListNode | null, k: number): ListNode | null { let prev: ListNode | null = null; let curr: ListNode | null = head; while (k > 0 && curr !== null) { const next: ListNode | null = curr.next; curr.next = prev; prev = curr; curr = next; k--; } return prev; } ```

Author: nendroids

res/ino/483119582.jpg

@@ -0,0 +1,35 @@
+# [**25. Reverse Nodes in k-Group**](https://leetcode.com/problems/reverse-nodes-in-k-group/description/)
+
+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:**
+
+<img src="https://raw.githubusercontent.com/leetcoin-releases/leetcode/refs/heads/main/res/ino/483119582.jpg" style="width: 100%; height: 600;"/>
+
+```md
+Input: head = [1,2,3,4,5], k = 2
+Output: [2,1,4,3,5]
+```
+
+#### **Example 2:**
+
+<img src="https://raw.githubusercontent.com/leetcoin-releases/leetcode/refs/heads/main/res/ino/483119823.jpg" style="width: 100%; height: 600;"/>
+
+```md
+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:**
+```md
+Can you solve the problem in O(1) extra memory space?
+```

res/ino/483119823.jpg

@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ * int val;
+ * struct ListNode *next;
+ * };
+ */
+struct ListNode* reverseLinkedList(struct ListNode* head, int k) {
+ struct ListNode* prev = NULL;
+ struct ListNode* curr = head;
+ while (k > 0) {
+ struct ListNode* next = curr->next;
+ curr->next = prev;
+ prev = curr;
+ curr = next;
+ k--;
+ }
+ return prev;
+}
+struct ListNode* reverseKGroup(struct ListNode* head, int k) {
+ struct ListNode* curr = head;
+ int count = 0;
+ while (curr != NULL && count < k) {
+ curr = curr->next;
+ count++;
+ }
+ if (count == k) {
+ struct ListNode* reversedHead = reverseLinkedList(head, k);
+ head->next = reverseKGroup(curr, k);
+ return reversedHead;
+ }
+ return head;
+}

sol/solution/0001-0100/0025/README.md

@@ -0,0 +1,39 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ * int val;
+ * ListNode *next;
+ * ListNode() : val(0), next(nullptr) {}
+ * ListNode(int x) : val(x), next(nullptr) {}
+ * ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+ ListNode* reverseKGroup(ListNode* head, int k) {
+ ListNode* curr = head;
+ int count = 0;
+ while (curr != nullptr && count < k) {
+ curr = curr->next;
+ count++;
+ }
+ if (count == k) {
+ ListNode* reversedHead = reverseLinkedList(head, k);
+ head->next = reverseKGroup(curr, k);
+ return reversedHead;
+ }
+ return head;
+ }
+private:
+ ListNode* reverseLinkedList(ListNode* head, int k) {
+ ListNode* prev = nullptr;
+ ListNode* curr = head;
+ while (k--) {
+ ListNode* next = curr->next;
+ curr->next = prev;
+ prev = curr;
+ curr = next;
+ }
+ return prev;
+ }
+};

sol/solution/0001-0100/0025/Solution.c

@@ -0,0 +1,39 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * public int val;
+ * public ListNode next;
+ * public ListNode(int val=0, ListNode next=null) {
+ * this.val = val;
+ * this.next = next;
+ * }
+ * }
+ */
+public class Solution {
+ public ListNode ReverseKGroup(ListNode head, int k) {
+ ListNode curr = head;
+ int count = 0;
+ while (curr != null && count < k) {
+ curr = curr.next;
+ count++;
+ }
+ if (count == k) {
+ ListNode reversedHead = ReverseLinkedList(head, k);
+ head.next = ReverseKGroup(curr, k);
+ return reversedHead;
+ }
+ return head;
+ }
+ private ListNode ReverseLinkedList(ListNode head, int k) {
+ ListNode prev = null;
+ ListNode curr = head;
+ while (k > 0) {
+ ListNode next = curr.next;
+ curr.next = prev;
+ prev = curr;
+ curr = next;
+ k--;
+ }
+ return prev;
+ }
+}

sol/solution/0001-0100/0025/Solution.cpp

@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ * int val;
+ * ListNode? next;
+ * ListNode([this.val = 0, this.next]);
+ * }
+ */
+class Solution {
+ ListNode? reverseKGroup(ListNode? head, int k) {
+ ListNode? curr = head;
+ int count = 0;
+ while (curr != null && count < k) {
+ curr = curr.next;
+ count++;
+ }
+ if (count == k) {
+ final reversedHead = reverseLinkedList(head, k);
+ head?.next = reverseKGroup(curr, k);
+ return reversedHead;
+ }
+ return head;
+ }
+ ListNode? reverseLinkedList(ListNode? head, int k) {
+ ListNode? prev = null;
+ ListNode? curr = head;
+ int remainingK = k;
+ while (remainingK > 0 && curr != null) {
+ final next = curr.next;
+ curr.next = prev;
+ prev = curr;
+ curr = next;
+ remainingK--;
+ }
+ return prev;
+ }
+}

sol/solution/0001-0100/0025/Solution.cs

@@ -0,0 +1,26 @@
+%% Definition for singly-linked list.
+%%
+%% -record(list_node, {val = 0 :: integer(),
+%% next = null :: 'null' | #list_node{}}).
+-spec reverse_k_group(Head :: #list_node{} | null, K :: integer()) -> #list_node{} | null.
+reverse_k_group(Head, K) when K =< 1 -> Head;
+reverse_k_group(Head, K) when Head =:= null -> null;
+reverse_k_group(Head, K) ->
+ List = to_list(Head),
+ NewList = reverse_k_chunks(List, K),
+ from_list(NewList).
+to_list(null) -> [];
+to_list(#list_node{val = V, next = Next}) -> [V | to_list(Next)].
+from_list([]) -> null;
+from_list([H | T]) -> #list_node{val = H, next = from_list(T)}.
+reverse_k_chunks(List, K) ->
+ Groups = reverse_k_chunks(List, K, []),
+ lists:append(Groups).
+reverse_k_chunks([], _K, Acc) -> lists:reverse(Acc);
+reverse_k_chunks(List, K, Acc) ->
+ {Chunk, Rest, Len} = take_chunk(List, K, [], 0),
+ Group = if Len == K -> Chunk; true -> lists:reverse(Chunk) end,
+ reverse_k_chunks(Rest, K, [Group | Acc]).
+take_chunk(Rest, 0, Chunk, Len) -> {Chunk, Rest, Len};
+take_chunk([], _K, Chunk, Len) -> {Chunk, [], Len};
+take_chunk([H | T], K, Chunk, Len) -> take_chunk(T, K - 1, [H | Chunk], Len + 1).

sol/solution/0001-0100/0025/Solution.dart

@@ -0,0 +1,31 @@
+# Definition for singly-linked list.
+#
+# defmodule ListNode do
+# @type t :: %__MODULE__{
+# val: integer,
+# next: ListNode.t() | nil
+# }
+# defstruct val: 0, next: nil
+# end
+defmodule Solution do
+ @spec reverse_k_group(head :: ListNode.t | nil, k :: integer) :: ListNode.t | nil
+ def reverse_k_group(head, k) when k <= 1 or head == nil, do: head
+ def reverse_k_group(head, k) do
+ {nodes, rest, count} = take_nodes(head, k, [], 0)
+ if count < k do
+ head
+ else
+ rest_rev = reverse_k_group(rest, k)
+ build_reversed(nodes, rest_rev)
+ end
+ end
+ defp take_nodes(node, 0, acc, count), do: {Enum.reverse(acc), node, count}
+ defp take_nodes(nil, _k, acc, count), do: {Enum.reverse(acc), nil, count}
+ defp take_nodes(%ListNode{} = node, k, acc, count) do
+ take_nodes(node.next, k - 1, [node | acc], count + 1)
+ end
+ defp build_reversed([], acc), do: acc
+ defp build_reversed([%ListNode{val: v} | t], acc) do
+ build_reversed(t, %ListNode{val: v, next: acc})
+ end
+end

sol/solution/0001-0100/0025/Solution.erl

@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ * Val int
+ * Next *ListNode
+ * }
+ */
+func reverseKGroup(head *ListNode, k int) *ListNode {
+ curr := head
+ count := 0
+ for curr != nil && count < k {
+ curr = curr.Next
+ count++
+ }
+ if count == k {
+ reversedHead := reverseLinkedList(head, k)
+ head.Next = reverseKGroup(curr, k)
+ return reversedHead
+ }
+ return head
+}
+func reverseLinkedList(head *ListNode, k int) *ListNode {
+ var prev *ListNode = nil
+ curr := head
+ for k > 0 && curr != nil {
+ next := curr.Next
+ curr.Next = prev
+ prev = curr
+ curr = next
+ k--
+ }
+ return prev
+}