Reverse Linked List in Chunks

Problem Statement:
                   Reverse a given linked list in chunks of given size.

Given below is the linked list which is reversed in chunks of size 3.

Solution : 

The above problem can be solved both by 

1. Recursion 
2. Iteration

Full Source Code: LINK

1. Below is recursive implementation: 

       The below sub routine use a another sub-routine which helps in reversing the list of the chunk size.

public Node reverseInchunks(Node root, int k){

  if(root==null)
   return null;

  Node first=root;
  Node current=first;

  int count = k-1;
  while(current.next!=null && count > 0)
  {
   current=current.next;
   count--;
  }

  Node  last=reverseInchunks(current.next,k);
  current.next=null;
  
  Node subHead=reverse(first);

  first.next=last;

  return subHead;
 }

 public Node  reverse(Node head) {

  Node result;
  if(head.next ==null) 
   return head;

  result = reverse(head.next);

  head.next.next = head;

  head.next = null;

  return result;
 }

  

2. You can also be asked to reverse the list iteratively, below is the solution.

  public Node reverseChunkIterative(Node head, int k){

  if(head==null)
   return null;
  
  Node first, previous,last;
  first= previous=last=null;
 
  Node current=head;
  
  while(current!=null){
   

   Node temp=current; 
   previous =null;
   Node next=null;
   int count =k;
            
   while(current!=null  && count>0){
    next = current.next;
    current.next = previous ;
    previous = current ;
    current = next;
    count--;
   }
   
   if(first == null)
    first = previous;
   else
    last.next=previous;

   last=temp;
  }
  return first;
 }

 

For the simulation of the above procedures on ideone.com follow the link given above.
Thanks to Rohit Jain for suggesting the recursive solution.

Your suggestions, queries , critiques are most welcome , feel free to comment.

Happy Coding !! :)