I’m working on a problem where I need to reverse nodes in a singly linked list in groups of k. The solution needs to be in-place, meaning I can’t use extra space beyond a few variables. I’ve tried several approaches but am struggling to get an efficient solution that meets these requirements.

Here are the specific requirements:

Reverse nodes in k-groups.
If the number of nodes is not a multiple of k, the remaining nodes at the end should remain as they are.
The solution must be in-place.
For example, given the linked list 1 -> 2 -> 3 -> 4 -> 5 and k = 3, the output should be 3 -> 2 -> 1 -> 4 -> 5.

Here’s a simplified version of my linked list implementation:

`
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }

}

public class ReverseKGroup {

public static ListNode reverseKGroup(ListNode head, int k) {
    // Implement the logic here
}

public static void main(String[] args) {
    ListNode head = new ListNode(1);
    head.next = new ListNode(2);
    head.next.next = new ListNode(3);
    head.next.next.next = new ListNode(4);
    head.next.next.next.next = new ListNode(5);

    int k = 3;
    ListNode newHead = reverseKGroup(head, k);

    // Print the reversed list
    while (newHead != null) {
        System.out.print(newHead.val + " -> ");
        newHead = newHead.next;
        }
    }
}
`

How can I implement the reverseKGroup method to reverse the nodes in k-groups efficiently and in-place? Any detailed explanation or code example would be greatly appreciated!