Python Program For Reversing Alternate K Nodes In A Singly Linked List

# 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 the 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 point 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("Modified Linked list") 
    printList(head) 
# This code is contributed by Srathore

# 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 call 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("Modified Linked list ") 
printList(head) 
# This code is contributed by Arnab Kundu