# LeetCode – Reverse Nodes in k-Group (Java)

Given a linked list, reverse the nodes of a linked list k at a time and return its modified 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 nodes, only nodes itself may be changed.

For example,

```Given this linked list: 1->2->3->4->5
For k = 2, you should return: 2->1->4->3->5
For k = 3, you should return: 3->2->1->4->5
```

Java Solution

```public ListNode reverseKGroup(ListNode head, int k) { if(head==null||k==1) return head;   ListNode fake = new ListNode(0); fake.next = head; ListNode prev = fake; int i=0;   ListNode p = head; while(p!=null){ i++; if(i%k==0){ prev = reverse(prev, p.next); p = prev.next; }else{ p = p.next; } }   return fake.next; }```
```public ListNode reverse(ListNode prev, ListNode next){ ListNode last = prev.next; ListNode curr = last.next;   while(curr != next){ last.next = curr.next; curr.next = prev.next; prev.next = curr; curr = last.next; }   return last; }```

We can write the reverse method differently like the following. I personally it is more understandable. ```private ListNode reverse(ListNode prev, ListNode next){ ListNode p1 = prev.next; ListNode p2 = p1.next;   while(p2 != next){ ListNode t = p2.next; p2.next = p1; p1 = p2; p2 = t; }   ListNode rNode = prev.next;   prev.next.next = next; prev.next = p1;   return rNode; }```
Category >> Algorithms
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
```<pre><code>
String foo = "bar";
</code></pre>
```
• thecodingchannel
• Cat Racket
• SG

Reverse K group using stack.

public void reverseKGroup(int k){
Stack tempStack = new Stack();
Node current = root;
Node previous = null;
int i = 0;
while(current != null){
if(i!=0 && i%k == 0){
Node curr = tempStack.pop();
if(i==k){
root = curr;
}else{
previous.next = curr;
}
while(!tempStack.empty()){
Node n = tempStack.pop();
curr.next = n;
curr = n;
}
curr.next = current;
previous = curr;
}
tempStack.push(current);
current = current.next;
i++;
}

if(i%k == 0){
Node curr = tempStack.pop();
previous.next = curr;
while(!tempStack.empty()){
Node n = tempStack.pop();
curr.next = n;
curr = n;
}
curr.next = current;
previous = curr;
}
}