Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in an efficient way. Give the complexity of your algorithm.
Example:
Inputs: 1->2->3->4->5->6->7->8->9->NULL and k = 3 Output: 3->2->1->4->5->6->9->8->7->NULL.
Method 1 (Process 2k nodes and recursively call for rest of the list):
This method is basically an extension of the method discussed in this post.
kAltReverse(struct node *head, int k) 1) Reverse first k nodes. 2) In the modified list head points to the kth node. So change next of head to (k+1)th node 3) Move the current pointer to skip next k nodes. 4) Call the kAltReverse() recursively for rest of the n - 2k nodes. 5) Return new head of the list.
// C++ program to reverse alternate // k nodes in a linked list #include <bits/stdc++.h> using namespace std;
// Link list node class Node
{ public :
int data;
Node* next;
}; /* Reverses alternate k nodes and returns the pointer to the new
head node */
Node *kAltReverse(Node *head, int k)
{ Node* current = head;
Node* next;
Node* prev = NULL;
int count = 0;
/* 1) reverse first k nodes of the
linked list */
while (current != NULL && count < k)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
count++;
}
/* 2) Now head points to the kth node.
So change next of head to (k+1)th node*/
if (head != NULL)
head->next = current;
/* 3) We do not want to reverse next k
nodes. So move the current
pointer to skip next k nodes */
count = 0;
while (count < k-1 &&
current != NULL )
{
current = current->next;
count++;
}
/* 4) Recursively call for the list
starting from current->next. And make
rest of the list as next of first node */
if (current != NULL)
current->next = kAltReverse(current->next, k);
/* 5) prev is new head of the input list */
return prev;
} // UTILITY FUNCTIONS // Function to push a node void push(Node** head_ref,
int new_data)
{ // Allocate node
Node* new_node = new Node();
// Put in the data
new_node->data = new_data;
// Link the old list of the
// new node
new_node->next = (*head_ref);
// Move the head to point to the
// new node
(*head_ref) = new_node;
} // Function to print linked list void printList(Node *node)
{ int count = 0;
while (node != NULL)
{
cout<<node->data<< " " ;
node = node->next;
count++;
}
} // Driver code int main( void )
{ // Start with the empty list
Node* head = NULL;
int i;
// Create a list
// 1->2->3->4->5...... ->20
for (i = 20; i > 0; i--)
push(&head, i);
cout << "Given linked list " ;
printList(head);
head = kAltReverse(head, 3);
cout << "Modified Linked list " ;
printList(head);
return (0);
} // This code is contributed by rathbhupendra |
Output:
Given linked list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Modified Linked list 3 2 1 4 5 6 9 8 7 10 11 12 15 14 13 16 17 18 20 19
Time Complexity: O(n)
Auxiliary Space: O(1)
Method 2 (Process k nodes and recursively call for rest of the list):
The method 1 reverses the first k node and then moves the pointer to k nodes ahead. So method 1 uses two while loops and processes 2k nodes in one recursive call.
This method processes only k nodes in a recursive call. It uses a third bool parameter b which decides whether to reverse the k elements or simply move the pointer.
_kAltReverse(struct node *head, int k, bool b) 1) If b is true, then reverse first k nodes. 2) If b is false, then move the pointer k nodes ahead. 3) Call the kAltReverse() recursively for rest of the n - k nodes and link rest of the modified list with end of first k nodes. 4) Return new head of the list.
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std;
// Link list node class node
{ public :
int data;
node* next;
}; // Helper function for kAltReverse() node * _kAltReverse(node *node, int k, bool b);
// Alternatively reverses the given // linked list in groups of given size k. node *kAltReverse(node *head, int k)
{ return _kAltReverse(head, k, true );
} /* Helper function for kAltReverse(). It reverses k nodes of the list only if
the third parameter b is passed as true,
otherwise moves the pointer k nodes ahead
and recursively calls itself */
node * _kAltReverse(node *Node, int k, bool b)
{ if (Node == NULL)
return NULL;
int count = 1;
node *prev = NULL;
node *current = Node;
node *next;
/* The loop serves two purposes
1) If b is true,
then it reverses the k nodes
2) If b is false,
then it moves the current pointer */
while (current != NULL && count <= k)
{
next = current->next;
// Reverse the nodes only if b is true
if (b == true )
current->next = prev;
prev = current;
current = next;
count++;
}
/* 3) If b is true, then the node is the kth node.
So attach the rest of the list after the node.
4) After attaching, return the new head */
if (b == true )
{
Node->next = _kAltReverse(current, k, !b);
return prev;
}
/* If b is not true, then attach
rest of the list after prev.
So attach the rest of the list
after prev */
else
{
prev->next =
_kAltReverse(current, k, !b);
return Node;
}
} // UTILITY FUNCTIONS // Function to push a node void push(node** head_ref,
int new_data)
{ // Allocate node
node* new_node = new node();
// Put in the data
new_node->data = new_data;
// Link the old list of the
// new node
new_node->next = (*head_ref);
// Move the head to point to
// the new node
(*head_ref) = new_node;
} // Function to print linked list void printList(node *node)
{ int count = 0;
while (node != NULL)
{
cout << node->data << " " ;
node = node->next;
count++;
}
} // Driver Code int main( void )
{ // Start with the empty list
node* head = NULL;
int i;
// Create a list
// 1->2->3->4->5...... ->20
for (i = 20; i > 0; i--)
push(&head, i);
cout << "Given linked list " ;
printList(head);
head = kAltReverse(head, 3);
cout << "Modified Linked list " ;
printList(head);
return (0);
} // This code is contributed by rathbhupendra |
Output:
Given linked list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Modified Linked list 3 2 1 4 5 6 9 8 7 10 11 12 15 14 13 16 17 18 20 19
Time Complexity: O(n)
Auxiliary Space: O(n) for call stack because it is using recursion
Please refer complete article on Reverse alternate K nodes in a Singly Linked List for more details!