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 \n" ;
printList(head);
head = kAltReverse(head, 3);
cout<< "\n Modified Linked list \n" ;
printList(head);
return (0);
} // This code is contributed by rathbhupendra |
// Java program to reverse alternate k nodes in a linked list class LinkedList {
static Node head;
class Node {
int data;
Node next;
Node( int d) {
data = d;
next = null ;
}
}
/* Reverses alternate k nodes and
returns the pointer to the new head node */
Node kAltReverse(Node node, int k) {
Node current = node;
Node next = null , 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 (node != null ) {
node.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;
}
void printList(Node node) {
while (node != null ) {
System.out.print(node.data + " " );
node = node.next;
}
}
void push( int newdata) {
Node mynode = new Node(newdata);
mynode.next = head;
head = mynode;
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
// Creating the linkedlist
for ( int i = 20 ; i > 0 ; i--) {
list.push(i);
}
System.out.println( "Given Linked List :" );
list.printList(head);
head = list.kAltReverse(head, 3 );
System.out.println( "" );
System.out.println( "Modified Linked List :" );
list.printList(head);
}
} // This code has been contributed by Mayank Jaiswal |
# Python3 program to reverse alternate # k nodes in a linked list import math
# Link list node class Node:
def __init__( self , data):
self .data = data
self . next = None
# Reverses alternate k nodes and #returns the pointer to the new head node def kAltReverse(head, k) :
current = head
next = None
prev = None
count = 0
#1) reverse first k nodes of the linked list
while (current ! = None and count < k) :
next = current. next
current. next = prev
prev = current
current = next
count = count + 1 ;
# 2) Now head pos to the kth node.
# So change next of head to (k+1)th node
if (head ! = None ):
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 and current ! = None ):
current = current. next
count = count + 1
# 4) Recursively call for the list
# starting from current.next. And make
# rest of the list as next of first node
if (current ! = None ):
current. next = kAltReverse(current. next , k)
# 5) prev is new head of the input list
return prev
# UTILITY FUNCTIONS # Function to push a node def push(head_ref, new_data):
# allocate node
new_node = Node(new_data)
# 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 po to the new node
head_ref = new_node
return head_ref
# Function to print linked list def printList(node):
count = 0
while (node ! = None ):
print (node.data, end = " " )
node = node. next
count = count + 1
# Driver code if __name__ = = '__main__' :
# Start with the empty list
head = None
# create a list 1.2.3.4.5...... .20
for i in range ( 20 , 0 , - 1 ):
head = push(head, i)
print ( "Given linked list " )
printList(head)
head = kAltReverse(head, 3 )
print ( "\nModified Linked list" )
printList(head)
# This code is contributed by Srathore |
// C# program to reverse alternate // k nodes in a linked list using System;
class LinkedList
{ static Node head;
public class Node
{
public int data;
public Node next;
public Node( int d)
{
data = d;
next = null ;
}
}
/* Reverses alternate k nodes and
returns the pointer to the new head node */
Node kAltReverse(Node node, int k)
{
Node current = node;
Node next = null , 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 (node != null )
{
node.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;
}
void printList(Node node)
{
while (node != null )
{
Console.Write(node.data + " " );
node = node.next;
}
}
void push( int newdata)
{
Node mynode = new Node(newdata);
mynode.next = head;
head = mynode;
}
// Driver code
public static void Main(String []args)
{
LinkedList list = new LinkedList();
// Creating the linkedlist
for ( int i = 20; i > 0; i--)
{
list.push(i);
}
Console.WriteLine( "Given Linked List :" );
list.printList(head);
head = list.kAltReverse(head, 3);
Console.WriteLine( "" );
Console.WriteLine( "Modified Linked List :" );
list.printList(head);
}
} // This code has been contributed by Arnab Kundu |
<script> // JavaScript program to reverse // alternate k nodes in a linked list class Node { constructor(d)
{
this .data = d;
this .next = null ;
}
} let head; // Reverses alternate k nodes and returns // the pointer to the new head node function kAltReverse(node, k)
{ let current = node;
let next = null , prev = null ;
let 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 (node != null )
{
node.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;
} function printList(node)
{ while (node != null )
{
document.write(node.data + " " );
node = node.next;
}
} function push(newdata)
{ let mynode = new Node(newdata);
mynode.next = head;
head = mynode;
} // Driver code // Creating the linkedlist for (let i = 20; i > 0; i--)
{ push(i);
} document.write( "Given Linked List :<br>" );
printList(head); head = kAltReverse(head, 3); document.write( "<br>" );
document.write( "Modified Linked List :<br>" );
printList(head); // This code is contributed by rag2127 </script> |
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)
Space Complexity: O(n)
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.
#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 node is the kth node.
So attach rest of the list after 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 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 \n" ;
printList(head);
head = kAltReverse(head, 3);
cout << "\nModified Linked list \n" ;
printList(head);
return (0);
} // This code is contributed by rathbhupendra |
#include<stdio.h> #include<stdlib.h> /* Link list node */ struct node
{ int data;
struct node* next;
}; /* Helper function for kAltReverse() */ struct node * _kAltReverse( struct node *node, int k, bool b);
/* Alternatively reverses the given linked list in groups of given size k. */
struct node *kAltReverse( struct 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 */
struct node * _kAltReverse( struct node *node, int k, bool b)
{ if (node == NULL)
return NULL;
int count = 1;
struct node *prev = NULL;
struct node *current = node;
struct 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 node is the kth node.
So attach rest of the list after 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 rest of the list after prev */ else
{
prev->next = _kAltReverse(current, k, !b);
return node;
}
} /* UTILITY FUNCTIONS */ /* Function to push a node */ void push( struct node** head_ref, int new_data)
{ /* allocate node */
struct node* new_node =
( struct node*) malloc ( sizeof ( struct 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( struct node *node)
{ int count = 0;
while (node != NULL)
{
printf ( "%d " , node->data);
node = node->next;
count++;
}
} /* Driver program to test above function*/ int main( void )
{ /* Start with the empty list */
struct node* head = NULL;
int i;
// create a list 1->2->3->4->5...... ->20
for (i = 20; i > 0; i--)
push(&head, i);
printf ( "\n Given linked list \n" );
printList(head);
head = kAltReverse(head, 3);
printf ( "\n Modified Linked list \n" );
printList(head);
getchar ();
return (0);
} |
// Java program to reverse alternate k nodes in a linked list class LinkedList {
static Node head;
class Node {
int data;
Node next;
Node( int d) {
data = d;
next = null ;
}
}
/* 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, boolean b) {
if (node == null ) {
return null ;
}
int count = 1 ;
Node prev = null ;
Node current = node;
Node next = null ;
/* 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 node is the kth node.
So attach rest of the list after 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 rest of the list after prev */ else {
prev.next = _kAltReverse(current, k, !b);
return node;
}
}
void printList(Node node) {
while (node != null ) {
System.out.print(node.data + " " );
node = node.next;
}
}
void push( int newdata) {
Node mynode = new Node(newdata);
mynode.next = head;
head = mynode;
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
// Creating the linkedlist
for ( int i = 20 ; i > 0 ; i--) {
list.push(i);
}
System.out.println( "Given Linked List :" );
list.printList(head);
head = list.kAltReverse(head, 3 );
System.out.println( "" );
System.out.println( "Modified Linked List :" );
list.printList(head);
}
} // This code has been contributed by Mayank Jaiswal |
# Python code for above algorithm # Link list node class node:
def __init__( self , data):
self .data = data
self . next = next
# function to insert a node at the # beginning of the linked list def push(head_ref, new_data):
# allocate node
new_node = node( 0 )
# put in the data
new_node.data = new_data
# link the old list to the new node
new_node. next = (head_ref)
# move the head to point to the new node
(head_ref) = new_node
return head_ref
""" Alternatively reverses the given linked list in groups of given size k. """ def kAltReverse(head, 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 """ def _kAltReverse(Node, k, b) :
if (Node = = None ) :
return None
count = 1
prev = None
current = Node
next = None
""" 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 ! = None and count < = k) :
next = current. next
""" Reverse the nodes only if b is True"""
if (b = = True ) :
current. next = prev
prev = current
current = next
count = count + 1
""" 3) If b is True, then node is the kth node.
So attach rest of the list after node.
4) After attaching, return the new head """
if (b = = True ) :
Node. next = _kAltReverse(current, k, not b)
return prev
else :
""" If b is not True, then attach
rest of the list after prev.
So attach rest of the list after prev """
prev. next = _kAltReverse(current, k, not b)
return Node
""" Function to print linked list """ def printList(node) :
count = 0
while (node ! = None ) :
print ( node.data, end = " " )
node = node. next
count = count + 1
# Driver Code """ Start with the empty list """ head = None
i = 20
# create a list 1->2->3->4->5...... ->20 while (i > 0 ):
head = push(head, i)
i = i - 1
print ( "Given linked list " )
printList(head) head = kAltReverse(head, 3 )
print ( "\nModified Linked list " )
printList(head) # This code is contributed by Arnab Kundu |
// C# Program for converting // singly linked list into // circular linked list. using System;
public class LinkedList
{ static Node head;
public class Node
{
public int data;
public Node next;
public Node( int d)
{
data = d;
next = null ;
}
}
/* Reverses alternate k nodes and
returns the pointer to the new head node */
Node kAltReverse(Node node, int k)
{
Node current = node;
Node next = null , 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 (node != null )
{
node.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;
}
void printList(Node node)
{
while (node != null )
{
Console.Write(node.data + " " );
node = node.next;
}
}
void push( int newdata)
{
Node mynode = new Node(newdata);
mynode.next = head;
head = mynode;
}
public static void Main(String[] args)
{
LinkedList list = new LinkedList();
// Creating the linkedlist
for ( int i = 20; i > 0; i--)
{
list.push(i);
}
Console.WriteLine( "Given Linked List :" );
list.printList(head);
head = list.kAltReverse(head, 3);
Console.WriteLine( "" );
Console.WriteLine( "Modified Linked List :" );
list.printList(head);
}
} // This code is contributed 29AjayKumar |
<script> // javascript program to reverse alternate k nodes in a linked list var head;
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
/*
* Alternatively reverses the given linked list in groups of given size k.
*/
function kAltReverse(head , 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
*/
function _kAltReverse(node , k, b) {
if (node == null ) {
return null ;
}
var count = 1;
var prev = null ;
var current = node;
var next = null ;
/*
* 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 node is the kth node. So attach rest of the list after
* 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 rest of
* the list after prev
*/ else {
prev.next = _kAltReverse(current, k, !b);
return node;
}
}
function printList(node) {
while (node != null ) {
document.write(node.data + " " );
node = node.next;
}
}
function push(newdata) {
var mynode = new Node(newdata);
mynode.next = head;
head = mynode;
}
// Creating the linkedlist
for (i = 20; i > 0; i--) {
push(i);
}
document.write( "Given Linked List :<br/>" );
printList(head);
head = kAltReverse(head, 3);
document.write( "<br/>" );
document.write( "Modified Linked List :<br/>" );
printList(head);
// This code contributed by aashish1995 </script> |
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)
Space Complexity: O(n)
Please write comments if you find the above code/algorithm incorrect, or find other ways to solve the same problem.